Meta shipped a terminal coding agent on 5 August 2026. It installs with one curl command, runs autonomously across a whole repository, and in one internal test it worked for 24 hours straight across more than a thousand tool calls.
It also loses to Claude Opus 5 on every benchmark Meta published, including Meta's own.
Both of those things are true, and neither is the interesting part. The interesting part is a pricing tier most of the coverage skipped, which offers you a 12x discount in exchange for your code.
Here is what Muse Code actually is, how it measures against the models you are probably already paying for, and the one clause that decides whether you can use it at all.
What Meta actually shipped
Muse Code is a terminal coding agent in beta that plans changes, writes code and validates results across large repositories. It installs on macOS or Linux with a single shell command and runs on Muse Spark 1.2, a coding model Meta co-trained alongside the agent so the two fit together.
Two details from Meta's announcement are worth more attention than the model itself.
It coordinates persistent subagents. The main loop delegates to async background agents rather than doing everything in one context. That is the same architectural move the other serious agent frameworks have converged on.
It keeps a local event log. Every model call, tool run, approval and edit is appended to one file. Meta describes the result as "replay-exact and restart-safe", which means the agent resumes precisely where it stopped after a crash.
That second one is the genuinely new idea here, and we will come back to it.
Every vendor claims their agent runs for hours. Only some of them can tell you what it did.
How it compares on the benchmarks
Muse Spark 1.2 trails Claude Opus 5 on all three benchmarks Meta published, including the one Meta built itself.
| Benchmark | Claude Opus 5 | Muse Spark 1.2 | GPT-5.6 Terra | Gap to leader |
|---|---|---|---|---|
| Terminal-Bench 2.1 | 86.7% | 82.9% | 81.8% | 3.8 points |
| DeepSWE 1.1 | 65.0% | 59.3% | 64.8% | 5.7 points |
| Meta Internal Coding Bench | 79.4% | 70.6% | Not published | 8.8 points |
Read the last row twice. On Meta's own internal coding benchmark, the model Meta trained for coding scores 8.8 points below Claude Opus 5. Publishing that takes some confidence, and it tells you Meta is not competing on raw capability.
Scores are as reported in coverage of the launch. Meta's own blog post shows the comparison as charts without printing the numbers, which is a choice.
What each model costs to run
This is where Muse Spark gets interesting. It is materially cheaper than either frontier competitor.
| Model | Input per 1M | Cached input | Output per 1M | Context |
|---|---|---|---|---|
| Muse Spark 1.2 standard | $1.25 | $0.15 | $4.25 | 1,048,576 |
| Muse Spark 1.2 contributor | $0.10 | Not published | $0.20 | 1,048,576 |
| Claude Opus 5 | $5.00 | $0.50 | $25.00 | 1M |
| Claude Sonnet 5 | $2.00 | $0.20 | $10.00 | 1M |
| GPT-5.6 Terra | $2.00 | $0.20 | $12.00 | Not published |
| GPT-5.6 Sol | $5.00 | $0.50 | $30.00 | Not published |
Claude figures are from Anthropic's pricing page and GPT figures from OpenAI's. Claude Sonnet 5 is at introductory pricing until 31 August 2026, after which it moves to $3 and $15.
On output tokens, which dominate an agent's bill, Muse Spark 1.2 standard is roughly six times cheaper than Claude Opus 5 for a benchmark gap of under four points on Terminal-Bench. For a lot of work that is a straightforward trade.
Worth flagging: Meta's announcement post does not publish pricing at all. These figures come from launch coverage rather than a Meta pricing page, so confirm them before you build a budget on them.
Output tokens are where an agent's bill actually lives. A model that is cheap on input and expensive on output has not saved you anything.
The contributor tier is the real story
Meta offers a second pricing tier called muse-spark-1.2-contributor at $0.10 per million input tokens and $0.20 per million output. Against the standard tier that is 12.5x cheaper on input and 21.25x cheaper on output.
The price of that discount is permission to train future Meta models on your prompts and completions.
For an agent, "your prompts" means your source code. A terminal coding agent working across a repository sends the code it reads into the context window. That is not an edge case, it is the entire mechanism.
The contributor tier is not a discount on inference. It is Meta buying training data, and the currency is your repository.
Whether that is a good deal depends entirely on whose code it is.
If it is your own product code and you do not mind, the economics are hard to argue with. $0.20 per million output tokens against Claude Opus 5's $25 is a different category of spending, and it makes continuous background agents affordable in a way they were not last month.
If you handle client code, it is disqualifying. Most client contracts contain a confidentiality clause that prohibits disclosing their code to third parties, and sending it to a vendor with explicit training rights is disclosure. No sensible reading survives that. We build AI tools and agents under exactly those contracts, and this tier is not available to us on any project.
The uncomfortable version: the cheapest agent inference on the market right now is priced for people who do not have to ask a client first.
Why the event log matters more than the model
The event log is the part of Muse Code worth stealing regardless of which model you run.
Long-running agents fail in a specific way. They work for forty minutes, hit a transient API error, and you lose the entire run because the state lived in a process that just died. The usual answer is to make runs shorter, which limits what an agent can do.
Appending every model call, tool run, approval and edit to a local log changes the failure mode. A crash becomes a resume rather than a restart. It also gives you something most agent setups lack: an audit trail of what the agent actually did, in order, which is the only way to debug a run that went wrong three hours in.
This matters more as agents run longer. Meta's own example is a model optimising GPU kernels over 1,000-plus tool calls and 24 hours of continuous work. At that duration, an agent without durable state is a lottery ticket.
We looked at the framework layer beneath this in Claude Agent SDK vs LangGraph vs OpenAI Agents SDK. The short version is that durable execution is the thing to evaluate on, and it is why LangGraph exists.
Which one should you actually run
Pick on your constraint, not on the benchmark table.
Run Claude Opus 5 when correctness is the expensive variable. It leads every published benchmark here, including Meta's. On work where a wrong change costs more than the tokens did, paying six times more for the top score is not extravagance, it is arithmetic. Production migrations, anything touching payments, anything you cannot easily revert.
Run Muse Spark 1.2 standard when volume is the expensive variable. Test generation, refactors with good coverage behind them, dependency bumps, codemods across hundreds of files. Work where the output is cheap to verify and expensive to produce by hand. Under four points of benchmark gap for six times less money is a good trade when a failure is visible immediately.
Run GPT-5.6 Terra if you are already committed to that ecosystem. It sits between the two on both price and score, and switching costs are real.
Do not run the contributor tier on anything you do not own outright. This is not a preference. It is a contract question, and the answer for most agency and client work is no.
Common mistakes
Reading the benchmark gap as the whole story. A 3.8 point difference on Terminal-Bench does not mean the cheaper model fails 3.8% more often on your codebase. Benchmarks measure a distribution of tasks that is not your distribution. Run all three on ten real tickets from your own backlog before deciding.
Missing what the contributor tier costs. The discount is enormous and the terms are one line in the pricing table. If someone on your team picks the cheaper model string without reading it, you have made a disclosure decision by accident.
Assuming a terminal agent is a drop-in for your IDE workflow. Muse Code is macOS and Linux only and lives in the terminal. If your team is on Windows or works primarily in an IDE assistant, this is a different tool for a different job.
Treating a 24-hour autonomous run as a feature you want. It is a capability, not a default. An agent that works unsupervised for a day produces a diff nobody watched being made. Decide what the review process is before you decide you want the capability.
Comparing against the wrong Claude model. Opus 5 is the expensive tier. If you are cost-sensitive, the honest comparison for Muse Spark 1.2 is Claude Sonnet 5 at $2 and $10, not Opus 5 at $5 and $25.
Key takeaways
- Muse Code is a beta terminal coding agent from Meta, released 5 August 2026, running on the Muse Spark 1.2 model, macOS and Linux only.
- Muse Spark 1.2 trails Claude Opus 5 on all three published benchmarks: 82.9% against 86.7% on Terminal-Bench 2.1, 59.3% against 65.0% on DeepSWE 1.1, and 70.6% against 79.4% on Meta's own internal coding benchmark.
- At $1.25 input and $4.25 output per million tokens, the standard tier is roughly six times cheaper than Claude Opus 5 on output for a benchmark gap under four points.
- The contributor tier drops that to $0.10 and $0.20, a 12.5x and 21.25x reduction, in exchange for permission to train future Meta models on your prompts and completions.
- For a coding agent, "your prompts" means your source code, which makes the contributor tier unusable for most client work under a confidentiality clause.
- The local event log making runs replay-exact and restart-safe is the most reusable idea in the release, independent of which model you run.
- Meta's announcement post publishes benchmark charts without numbers and no pricing at all, so verify both before committing a budget.
Deciding which model to point at which job is most of the work, and it is the part that does not show up in a benchmark table. If you want that decision made against your actual codebase rather than a leaderboard, that is what we do at AI tools and agents.
