Meta pulled Muse Code out of beta on August 31, 2026, and the timing is not accidental. Anthropic has been steadily tightening Claude Code usage limits over the past two months, OpenAI’s Codex CLI is still invitation-gated for most developers, and a new wave of cheaper coding agents has been crowding the market. Meta’s pitch is direct: the same terminal-first, multi-agent coding workflow as Claude Code, powered by its Muse Spark 1.2 model, with a Contributor pricing tier that costs roughly 12 to 20 times less per token if you let Meta train on your prompts.
The catch is the data clause. The reward is one of the most aggressively priced APIs in the category today. This article breaks down what Muse Code actually ships with, how its pricing stacks up against Claude Code and OpenCode, why the Claude Code rate-limit squeeze matters right now, and how to get it running on Windows (Meta’s docs only list macOS and Linux, but it works fine on WSL).
What Is Muse Code and What Meta Just Shipped?
Muse Code is Meta Superintelligence Labs’ terminal-native coding agent, launched in public beta on August 5, 2026, and taken out of beta on August 31. It is a single-command install that drops a binary called Muse into your path on macOS or Linux, signs you in with a Meta Model API account, and turns a project directory into an interactive coding session that plans, edits, runs commands, and validates its own work. The August 31 update announced four headline additions:
- Inter-session messaging. Multiple Muse Code sessions running in parallel can now pass messages to each other over a local Unix socket, so a planning session can hand a resolved question to a build session without the developer retyping anything.
- Workflows. A built-in orchestrator that fans a large task out into parallel subagents, shows live progress under /workflows, and lets you stop, restart, cancel, or save reusable workflows.
- Rewind. Double-Esc now rewinds a session to an earlier safe checkpoint from the event log, with confirmation before any code is reverted.
- SDK (developer preview). A TypeScript library that exposes the CLI’s session, tool, and permission machinery over the open Muse Session Protocol, so you can embed Muse Code inside your own tools.
Under the hood, Muse Code runs on Muse Spark 1.2, a coding-focused update to Meta’s multimodal reasoning model with a 1,048,576-token context window. It is API-compatible with existing OpenAI and Anthropic SDKs, which means most existing code-agent integrations can switch providers with a one-line config change.
Muse Code vs Claude Code vs OpenCode: Head-to-Head
Muse Code is not entering an empty category. Anthropic’s Claude Code and the OpenCode open-source CLI have been setting the bar for terminal-native coding agents since early 2026. Here is how the three stack up today.
The full picture has more nuance than a single table can capture:
- Default model. Muse Code ships with Muse Spark 1.2 (closed weights). Claude Code defaults to Claude Sonnet 4.5 or Opus 4.1 depending on the plan. OpenCode is model-agnostic and runs whatever you point it at, including local Ollama models.
- Multi-agent design. All three support subagents, but Muse Code’s approach is the most opinionated. The parent agent automatically splits a task into child agents, each isolated in its own git worktree, with no opt-in flag needed. Claude Code requires explicit subagent invocations. OpenCode supports subagents but treats them as user-configured.
- Audit and replay. Muse Code records every subagent spawn, tool call, and decision in an append-only local event log, then lets you replay any step or hand the session back to a fresh instance. Claude Code’s session history is chat-scoped. OpenCode’s logging depends on which model backend you wire in.
- Privacy model. Anthropic’s consumer Claude Code plans retain prompts and completions by default unless you explicitly opt out. Meta’s Contributor tier does the reverse: it trains on your data unless you pay for Standard. Both default to data retention; the difference is who owns it.
- Windows support. Claude Code ships first-party Windows binaries. OpenCode is cross-platform out of the box. Muse Code’s docs only list macOS and Linux, which is why the WSL install method in Section 5 matters.
For a deeper look at how Anthropic built Claude Code around infrastructure rather than raw model intelligence, our earlier breakdown of the Claude Code architecture covers the design choices Meta is now emulating.
Muse Code Pricing: Standard vs. Contributor and the 20x Discount Explained
Muse Code itself is a free download. What you pay for is Muse Spark 1.2 tokens through the Meta Model API. There are two tiers, and the gap between them is unusually wide.
The exact published rates as of the August 31 announcement:
- Standard tier. $1.25 per million input tokens, $0.15 per million cached input tokens, $4.25 per million output tokens. This is the default, privacy-preserving tier. Prompts and completions are not used to train Meta models.
- Contributor tier. $0.10 per million input tokens, $0.002 per million cached input tokens, $0.20 per million output tokens. That is roughly a 12.5x discount on input and a 21.25x discount on output. In exchange, Meta can use your prompts and completions to improve its models.
There is no long-context premium and no separate cache-write fee: cached tokens are a subset of input tokens, the optional 24-hour retention hint costs nothing extra, and the rate is the same whether the 1M-token window is empty or nearly full. Several competing providers step pricing up past a context threshold. Meta does not.
The only add-on meter is web-search grounding, billed flat at $2.50 per 1,000 queries on top of tokens, regardless of how much context each search pulls. There is no IDE or GUI surcharge, and Meta’s own prompt-steering overhead is included.
Rate limits matter, too. The Standard tier is generous: 3,000 requests per minute and 4 million tokens per minute. The Contributor tier is throttled much harder at 100 requests per minute (a 30x reduction) and 3 million tokens per minute, measured over a rolling 5-hour window, and is available only in selected countries. Background submissions carry a third cap of 600 per minute on top.
For broader context, our updated LLM API pricing comparison puts Muse Spark 1.2 Contributor in the same cost band as several Chinese open-weight models and well below Claude Sonnet 4.5 and GPT-5 at list price.
Why Timing Matters: Claude Code Rate Limits Are Getting Tighter
The other reason Meta’s pricing pitch lands hard right now is that Anthropic has been quietly pulling Claude Code capacity back. Over the past several weeks, Claude Code users on Pro and Max plans have reported shorter rolling-window quotas, more frequent rate limit reached errors on long-running sessions, and tighter caps on Opus-tier model usage inside Claude Code. Anthropic has framed the changes as capacity management ahead of an enterprise push.
For developers who rely on Claude Code for multi-hour refactors or overnight agent sessions, the practical effect is that prompts get cut off mid-task more often. That is the exact use case Meta’s workflow orchestrator and parallel subagent design are aimed at, and it is why several early testers have already started running Muse Code alongside Claude Code for jobs where Anthropic throttles them out.
Claude Code’s $20/month Pro plan still has its place for chat-tier workloads, but heavy coding-agent users are increasingly looking for a second engine. Muse Code’s Contributor tier, at roughly 1/12th the per-token cost, is the most aggressive option on the market today. The trade-off, of course, is the data clause: Meta trains on Contributor prompts.
How to Install Muse Code (and the WSL Trick for Windows Users)
On macOS and Linux, the install is a one-liner:
- curl -fsSL https://dev.meta.ai/install.sh | bash
After install, you authenticate with your Meta Model API account, drop into any project directory, and run muse for an interactive session or muse exec “your prompt” for a headless run. That is the official path. Meta’s docs do not mention Windows anywhere in the launch materials.
The unofficial-but-functional path is WSL:
- Enable WSL. Open PowerShell as Administrator and run wsl –install. Reboot when prompted. On Windows 11, Ubuntu is installed by default. On Windows 10, install the Ubuntu distro from the Microsoft Store after the WSL enable.
- Update Ubuntu. Inside the Ubuntu terminal, run sudo apt update & sudo apt upgrade -y.
- Run the official Muse Code installer. The same one-liner works: curl -fsSL https://dev.meta.ai/install.sh | bash. The installer pulls the Linux binary, which WSL executes natively.
- Authenticate. Sign in with your Meta Model API account when prompted. Your credentials live inside the WSL filesystem.
- Edit Windows files from WSL. Your Windows drives mount under /mnt/c, /mnt/d, and so on. To work on a project stored in C:Users\you\Projects\myapp, navigate to /mnt/c/Users/you/Projects/myapp and run muse there.
Performance is effectively native. The Muse binary executes inside the Linux kernel context, file I/O goes through the standard 9P filesystem bridge, and the model calls hit Meta’s API over your normal network connection. The only practical friction is that file paths inside prompts need to use the WSL mount form (/mnt/c/…) rather than Windows form (C:…).
If WSL is not an option, Muse Code will not run on a stock Windows command prompt or PowerShell. There is no.exe build, no native port in the pipeline as of launch, and no WSL2-vs-WSL1 distinction that matters for Muse Code specifically.
Inside the Multi-Agent Architecture: Workflows, Subagents, and Git Worktrees
The most consequential design choice in Muse Code is not the model, it is the runtime. Muse Code is multi-agent by default rather than opt-in. When you hand it a non-trivial task, the parent agent automatically decides whether to fan it out into child agents. Each child agent gets:
- Its own isolated git worktree, so parallel writes never collide on the same files.
- Its own tool and permission scope, inherited from the parent unless you override it.
- Its own entry in the append-only event log, replayable from any point.
The fan-out cap scales with your machine’s core count minus two, clamped between 2 and 16 concurrent write-capable children.
On an 8-core machine you get up to 6 parallel writers. On a 16-core workstation you get up to 14. You can watch them live under /workflows, where the orchestrator surfaces each subagent’s status, lets you stop or cancel an individual branch, and lets you save a successful pattern as a reusable workflow.
The new Rewind feature leans on the same event log. Double-Esc opens a checkpoint picker that only offers safe points (a completed file write, a passed test run, and a confirmed merge). You pick one, confirm, and the conversation history rolls back. It is the same idea as Claude Code’s /rewind command and Cursor’s checkpoint UI, but it ships turned on by default in Muse Code rather than as a slash command.
The SDK preview extends the same primitives outward. Your TypeScript program spawns a local Muse host process and talks to it over the open Muse Session Protocol (MSP), a JSON-over-stdio contract with a generated schema. There is no server, no network call: everything runs locally. You can start a session in any workspace, stream the agent’s answer, decide permission requests from your own code, and reload the session later with state intact. Because types are generated from the protocol schema, your build breaks loudly if you drift from the engine.
For CI integration, the same headless form works: muse exec “fix the failing tests in test_user.py” runs the full multi-agent flow non-interactively and exits with a status code your pipeline can gate on.
The Contributor Trade-Off: What Meta Actually Does With Your Prompts
The Contributor tier’s discount is large enough that it deserves its own close read. Meta’s published terms for the muse-spark-1.2-contributor model say that prompts and completions may be used to improve Meta’s products. In practice, that means:
- Your source code snippets, function signatures, file paths, and architectural context become training data for future Muse Spark versions.
- Meta retains the right to log sessions for safety and quality work, including human review on a sampled basis.
- There is no per-prompt opt-out: the discount and the data clause are bundled. Standard tier is the only way to keep your prompts out of training.
This is structurally similar to Claude Code’s data policy under its consumer plans, where Anthropic retains prompts for 30 days by default unless you opt out. The asymmetry is pricing. Claude Code’s default tier runs through Claude Sonnet 4.5 at $3 per million input and $15 per million output tokens. Muse Code Contributor runs at $0.10 in and $0.20 out. For a developer doing heavy nightly runs, that is the difference between a $200 month and a $4 month, on roughly equivalent model capability.
Benchmarks and Real-World Performance
Muse Code’s launch shipped with one external benchmark number: 82.9% on Terminal-Bench 2.1, placing it second behind Claude Opus 5 and Claude Code, which scored 86.7%. Terminal-Bench 2.1 measures end-to-end agent performance on real terminal tasks across file editing, build orchestration, debugging, and multi-step workflows.
The 3.8-point gap to Claude Code is small enough that on a per-task basis the two are likely interchangeable. The bigger differentiator is the multi-agent design: when you hand both tools the same large refactor, Muse Code’s automatic fan-out and git worktree isolation lets parallel subagents edit disjoint files simultaneously, whereas Claude Code typically processes the same job in a more linear sequence.
Muse also highlighted an internal study in which the agent handled over 1,000 tool calls across a continuous 24-hour session without losing coherence, attributed to the append-only event log and the muse resume command that rebuilds session state from the log after a crash. Claude Code’s session recovery has historically been limited to chat history plus a project snapshot. The event-log approach is the more durable design, even if it is less polished in beta.
Frequently Asked Questions
Is Muse Code free?
The Muse Code binary is free to download and install. You pay for the underlying Muse Spark 1.2 model usage through the Meta Model API, at either the Standard or Contributor tier rates.
Can Muse Code run on Windows?
Not natively. Meta’s official install path lists macOS and Linux only. On Windows, the working method is WSL: enable WSL with wsl –install, install the Ubuntu distro, then run the standard Linux installer inside the Ubuntu terminal.
What is the difference between Muse Code and Claude Code?
Muse Code runs on Meta’s Muse Spark 1.2 with a 1M-token context, a multi-agent-by-default orchestrator with git worktree isolation, and a Contributor tier that is roughly 12 to 20 times cheaper per token. Claude Code runs on Claude Sonnet 4.5 or Opus 4.1 with tighter integration into the Anthropic ecosystem, first-party Windows binaries, and a more linear single-agent default workflow.
Is Muse Code better than OpenCode?
It depends on your priorities. Muse Code is opinionated, runs on a single high-quality closed model, and ships with built-in multi-agent orchestration out of the box. OpenCode is model-agnostic, open-source, and lets you point it at local models or any provider, including Ollama, OpenRouter, or your own self-hosted endpoint. For maximum model flexibility, choose OpenCode. For maximum out-of-the-box capability at minimum token cost, choose Muse Code.
Does Meta train on my code if I use the Contributor tier?
Yes. The Contributor tier’s discount is explicitly tied to Meta using your prompts and completions to improve its models. For proprietary or regulated code, the Standard tier at $1.25/$4.25 per million tokens is the only defensible option.
The Bottom Line
Muse Code is the most credible Claude Code alternative to land in 2026. It is faster to set up than Claude Code on Windows (via WSL), cheaper than Claude Code at the Contributor tier by a factor of 12 to 20, and architecturally more aggressive on the multi-agent side. The data clause is the price of admission for that discount, and the Claude Code squeeze is the reason the timing matters.
For developers priced out of Claude Code by rate limits, Muse Code is the obvious next stop. For teams handling sensitive code, it is worth running on Standard tier as a second engine alongside Claude Code. And for hobbyists and open-source maintainers, the Contributor tier’s economics are the most attractive API deal in the coding-agent category today.
