Meta Cut Its Coding Agent Bill 12x. The Currency Is Whatever the Agent Read.

Meta shipped Muse Code in early beta on 5 August alongside Muse Spark 1.2, and put the same model behind two IDs. muse-spark-1.2 runs at $1.25 per million input tokens and $4.25 per million output. muse-spark-1.2-contributor runs at $0.10 and $0.20, and Meta's documentation says that traffic "may be used to improve our products."

That is 12x on input, 21x on output, and 75x on cached input, where the contributor rate falls to $0.002 per million. The discount does not buy you a smaller model or a slower one. It is the same weights at a different data-use term.

The part worth slowing down on is what counts as a prompt here. Muse Code carries a 1M-token context window that Meta describes as holding dependency graphs, legacy code and thousands of files in one session. On the contributor tier, all of that is the prompt.

I have watched teams treat model pricing as a finance question for two years, because for two years it mostly was. A cheaper model meant a cheaper line item and a slightly worse answer. This is the first pricing page I have read where the cheaper number is not a capability tradeoff at all. It is a licensing decision, and it is being made in the same place and by the same person who picks a model.

The switch is a string

Tier selection is the model ID. One config value, one environment variable, one line in a script. Change muse-spark-1.2 to muse-spark-1.2-contributor and the bill drops by an order of magnitude and the data terms invert.

That is a clean API design and a genuinely awkward governance surface. Every other decision of this weight in your stack has friction attached. Adding a vendor means a review. Signing a DPA means legal. Granting a scope means someone approves it. Here the entire decision is a string an engineer can edit in thirty seconds, with a 12x saving as the standing incentive to edit it.

The failure mode is not a rogue developer selling the codebase. It is a Friday afternoon, a burn-rate dashboard, a prototype that got promoted, and nobody rereading the model ID that came along with it. The string travels with the config, and configs get copied.

What ends up in the window

The reason this matters more than a normal training-data checkbox is the shape of the product.

In a chat assistant, a prompt is roughly what you typed. You have a sense of what you disclosed because you wrote it. In an agentic harness with a million tokens of room, the agent decides what to read. It walks the dependency graph, opens the files it thinks are relevant, pulls in test fixtures, reads config, captures tool output, and holds all of it in the session.

You did not choose those files individually. You asked for a refactor. The disclosure surface is whatever the retrieval step decided was in scope, and Muse Code is explicitly built to make that surface large. The 1M window is the headline feature.

Meta's own auditability story is the useful counterweight, and it is better than most. Every subagent, every tool call, every steer and cancel gets written to an event log as plain JSONL on your disk, and muse resume replays it. Subagents run in isolated git worktrees. If you want to know what actually went into a session, the record is local and readable.

Which means the check is available to you and costs nothing to run. The log answers exactly the question the contributor tier makes expensive to get wrong, and it sits in a file you have to go open on purpose.

The discount has a second price

The contributor tier is not simply the same service for less. Meta's docs say it is rate-limited by tokens on a rolling five-hour window rather than by request count, and that it is available in select countries only.

Secondary coverage has published specific per-minute request ceilings for both tiers, and those numbers disagree with each other and with Meta's own wording, so I would not plan against any of them. The structural point survives the discrepancy: throughput on the cheap tier is capped over a multi-hour window, and the workload Muse Code is built for is the long-horizon kind. Meta demonstrated a run of more than a thousand tool calls over 24 hours on GPU kernel optimization. That is precisely the shape of job a rolling token budget throttles.

So the tier that costs a twelfth is also the tier least able to carry the flagship workload. For prototyping and open-source work it is a real bargain. For the persistent background agents in the pitch, you are likely paying standard rates anyway, which makes the contributor tier less of a procurement decision than the price gap suggests and more of a trap for the exact prototype that quietly becomes production.

The controls that usually govern this are still early

On capability, Muse Spark 1.2 is a price-performance play rather than a frontier claim, and Meta is reasonably straight about that. Meta-reported DeepSWE 1.1 puts it at 59.3 percent against Claude Opus 5 at 65.0 and GPT-5.6 Terra at 64.8. Meta reports 82.9 percent on Terminal-Bench 2.1 for the integrated system. Independent evaluation from Vals placed it fifth of 45 models on their composite index at 71.88 percent, with the lowest cost per test among the top five at $0.69.

Fifth place at the cheapest cost per test is a strong position. It is also the position that makes the data question live, because the pitch is cost, and the deepest cost lever on the page is the one that trains on your work.

The enterprise scaffolding is not there yet. Meta says it is beginning to accept requests for zero data retention on the standard tier through direct sales contact, which means ZDR is a conversation rather than a setting. Launch materials do not document enterprise pricing, SLA-backed contracts, admin consoles, SSO or server-side audit logs. This is an early beta and that is a fair stage to be at, but it means the organizational control you would normally use to prevent the wrong model ID reaching production does not currently exist as a product feature.

What I would do this week

Grep your configs and environment for -contributor before anything else. It takes a minute and it is the only question that has a wrong answer.

Write the classification down once, at the org level, and bind it to model IDs rather than to judgment. Public repositories and disposable prototypes can use contributor. Client work under NDA, anything regulated, anything touching credentials or customer data uses standard. An NDA is not permission to contribute a client's code to someone's training set, and no engineer should be resolving that question at runtime against a cost dashboard.

If you want the contributor tier for open-source work, and it is a good deal for open-source work, sanitize the machine-level context first. Agent harnesses load instruction files and project context automatically, and internal architecture notes or client names sitting in a global config will ride along into the first request without anyone deciding they should.

Then use the event log for what it is good for. Run one real task on standard rates, open the JSONL, and read what the agent actually pulled into context. That list is your disclosure surface if you ever flip the tier. Most teams have never looked at it, and the number of files is usually larger than the guess.

The pricing here is honest in a way I would rather have than not. Meta put the trade on the page instead of burying it in terms of service, and named the tier after what it does. The problem is not the offer, it is that a decision this consequential currently has less friction than adding a dependency.