Meta launched Muse Code in beta on August 5-6, 2026 — a terminal coding agent built on Muse Spark 1.2. The interesting part isn’t the model. It’s that Meta shipped this knowing it loses on the benchmarks it chose to publish, and priced it like a company that doesn’t need those benchmarks to win the deal.

The numbers, stated plainly

On Terminal-Bench 2.1 — a practical software-engineering benchmark — Muse Code ranks second, behind Claude Opus 5 (Anthropic’s own agent) and ahead of OpenAI’s Codex. Second place, on a leaderboard Meta didn’t design, against two competitors with a multi-year head start on agentic coding. That’s the honest framing before you look at anything else.

Now the pricing, which is where this gets strategically interesting:

  • Standard tier: $1.25 / 1M input tokens, $4.25 / 1M output tokens, $0.15 cached input
  • Contributor tier: $0.10 / 1M input tokens, $0.20 / 1M output tokens, $0.002 cached input — in exchange for Meta training on your prompts and completions

The contributor tier is roughly 12x cheaper on input and 21x cheaper on output than the standard tier. That’s not a rounding-error discount — it’s Meta explicitly telling the market “we’ll subsidize your usage if we get your data,” the same trade Meta has run with every free consumer product it’s ever shipped, now applied to enterprise dev tooling.

Architecture: the part that actually matters for a tech lead

Three design choices separate Muse Code from being “just another Claude Code clone”:

Persistent background agents. Sessions don’t die when your terminal closes. An agent can keep working on a long-running refactor or test suite while you’re in a meeting, and you reattach later. This is a genuine gap in most current terminal agents, which are tied to the lifetime of the shell session.

Worktree isolation by default. Each agent run gets its own git worktree, so parallel agents working on the same repo don’t stomp on each other’s uncommitted state. If you’ve ever had two agent sessions fight over the same working directory, this is the fix, and it’s built-in rather than something your team has to script.

Append-only local event log. Every action the agent takes is logged locally in an append-only format, which means you get a crash-safe audit trail without standing up separate infrastructure. For teams that need to explain “what did the agent actually do to this codebase” — which is increasingly a compliance question, not just a debugging one — this is worth more than a benchmark point.

The 1M token context window is the other headline number: it means you can load a meaningfully large codebase or a long incident timeline into a single session without the manual chunking gymnastics that eat real engineering hours.

Hands-on: where the pricing actually changes behavior

# Standard tier — production use, no data sharing
export MUSE_API_KEY="your-key"
muse-code --tier standard --model muse-spark-1.2 \
  --task "Refactor the payment retry logic in src/billing/retry.py to use exponential backoff with jitter"

# Contributor tier — internal tooling, non-sensitive repos
muse-code --tier contributor --model muse-spark-1.2 \
  --task "Generate a test suite for src/utils/date_parsing.py"

The pricing split maps cleanly onto a real internal policy: contributor tier for internal tools, docs generation, test scaffolding on non-sensitive repos — anything where “Meta sees this” is a non-issue. Standard tier for anything touching customer data, proprietary algorithms, or code under an NDA. That’s a policy your legal and security teams can actually sign off on in one meeting, because the boundary is priced, not just documented.

What I’d actually do with this

  1. Don’t evaluate Muse Code on Terminal-Bench alone. It’s second place there and that’s the number every article will quote. Run it on your own regression suite of past PRs — the same test I’d apply to any coding agent — before deciding it’s “worse.”
  2. Use the contributor tier as a forcing function for repo hygiene. If you’re going to route agent traffic based on “is this repo sensitive,” you need that classification anyway. Muse Code’s pricing just gives you a concrete reason to finish that audit this quarter instead of next.
  3. Test the persistent background agent feature specifically against your longest-running CI or refactor jobs. This is the one capability here that’s a genuine architectural difference, not a pricing trick — and it’s the one most likely to save real engineer-hours if it holds up under your workload.

Meta isn’t trying to win the “best agent” argument this release. It’s trying to win the “cheapest agent good enough to not need Claude Code for 80% of tasks” argument, and pricing a second-place model at a third of the going rate — with a contributor tier at a twelfth of it — is exactly how you make that argument on cost instead of capability.

Export for reading

Comments