Meta's Muse Code is up to 20x cheaper if it can train on your code. Decide your tier before anyone on your team installs it.

Meta released Muse Code on August 5: a terminal coding agent in the same category as Claude Code and Cursor, powered by its Muse Spark 1.2 model, in public beta for macOS and Linux with a one-command install. The launch coverage centers on the agent itself. The decision it forces is on the pricing page.

Muse Code's API has two tiers. The standard tier costs $1.25 per million input tokens and $4.25 per million output tokens, with cached input at $0.15, and Meta commits that your prompts and completions are not used to train its models. The contributor tier costs $0.10 per million input tokens and $0.20 per million output tokens, with cached input at $0.002. That is roughly 12x cheaper on input and 21x cheaper on output. The payment for the difference is explicit: you grant Meta permission to use your prompts and completions to train future models.

For a chat product, "prompts and completions" means your conversations. For a coding agent, it means your code. Muse Code plans changes, reads files for context, fans work out to sub-agents in isolated worktrees, and writes diffs back. Every file it reads travels as input tokens; every diff it writes comes back as output tokens. On the contributor tier, that traffic is training data. The agent does not distinguish between the file you asked about and the twelve files it pulled in as context, and the context sweep is exactly what makes agents useful on large repositories. It is also what makes the tier decision bigger than it looks: config files, internal APIs, vendored dependencies under licenses you cannot relicense, and anything a lazy .env handling lets through are all in scope.

Where the discount is a fair trade

If the code is yours to give, the contributor tier is a legitimately good deal. A solo builder running an agent through 50 million input and 10 million output tokens in a month pays about $7 on the contributor tier against about $105 on standard. Open-source work you already publish under a permissive license, personal projects, throwaway prototypes: the training grant costs you little, and the price makes agent-heavy workflows viable at hobby budgets.

Two caveats before you take it. First, check the rate limits, not just the prices: the published contributor limits are 60 requests per minute against 3,000 on standard. A multi-agent tool that fans out sub-agents eats requests quickly, so the cheap tier throttles the exact workloads the low price invites. Second, "permissive license" is your call to make only on code you own. A vendored GPL dependency in your repo is not yours to feed into a training corpus.

Where it is not your call to make

If you write code for an employer or a client, the contributor tier is not a pricing choice, it is a data-governance decision, and almost certainly not one an individual engineer is authorized to make. NDA-covered code, proprietary internal systems, client deliverables: granting a third party training rights on that material is the kind of thing contracts have clauses about.

The practical risk is not malice, it is defaults and drift. Muse Code installs with one command and the cheap tier is the obvious checkbox for anyone paying out of pocket or padding a team budget. That combination spreads faster than procurement review. If you run a team, the useful move today is one sentence in whatever channel your engineers read: which tier is approved, and whether Muse Code is approved at all. Writing that sentence after someone has run the agent across the monorepo for a week is a worse conversation.

The standard tier on its own merits

With the data question set aside, standard-tier Muse Code prices at $1.25/$4.25, below Claude Opus 5 at $5/$25 and in the same neighborhood as mid-tier models from other labs. Whether Muse Spark 1.2 holds up against the incumbents on large-repo work is a separate question the first weeks of public beta will answer; Meta's own claims about parallel feature building are vendor benchmarks until independent testing lands. The comparison worth making is workflow-shaped, not benchmark-shaped: Muse Code is terminal-native like Claude Code, not an IDE like Cursor, so the Cursor vs Claude Code split applies to it directly.

The durable part of this launch is the pricing structure. Frontier labs are short on high-quality code data, and real agent sessions on real repositories are among the most valuable training material there is, better than scraped GitHub and cheaper than synthetic data pipelines. A 20x discount is Meta naming the price it will pay for yours. Expect other vendors to copy the structure, and read every AI tool pricing page from now on with the question: what is the cheap tier paid with? When the answer is "your data," the tier picker is a contract, and it deserves the thirty seconds of thought a contract gets.