Muse Code: Crash-Replay and Worktrees Check

The data trade is the first price

A long refactor is the moment a coding agent either keeps its work or loses it. Muse Code is Meta's early-beta coding agent for long-running, multi-agent software work, available for macOS and Linux on Muse Spark 1.2. The contributor tier is roughly 12x below the standard tier on input and 21x below on output, and it grants Meta permission to use your prompts and completions for future model training. The features that matter for a long refactor are the replay log and the parallel worktrees. If they survive a real failure, the agent may be worth the price; if they do not, the benchmark score is decoration.

The five checks are the real test

• Force a mid-task crash on a long refactor, kill the process after at least one edit and one approval, then restart and compare the log to the claimed work. Muse Code keeps a pre-execution local audit trail of model calls, tool runs, approvals, and edits, and the log lets the runtime replay exactly and restart safely after a crash; a long job that fails 20 hours in can be restarted from the exact interruption point without losing work. Use a refactor that spans multiple files, not a one-line fix. The restart should match the log, with no duplicate edits, missing approvals, or divergent branch.
• Run parallel subagents on a large refactor, start with a job large enough to fan out, merge the results one at a time, and inspect the repository state. Muse Code can split a large job among write-capable subagents, giving each subagent its own git worktree, so parallel work does not collide on the same files and your main working copy remains untouched. Watch for file collisions, mixed branches, or a main copy that changes while children run.
• Calculate the token cost for your expected input and output mix before choosing a tier. Separate fresh context from cached context, because long refactors reuse prior state. The Contributor tier is priced at $0.10 per million input tokens and $0.20 per million output tokens, while the standard tier is priced at $1.25 per million input tokens and $4.25 per million output tokens, with standard cached input at $0.15. You are ready to pick a tier when you can state the dollar delta for fresh input and output.
• Check whether your code can train Meta. The standard tier's prompts and completions are excluded from model training. Meta imposed strict limits on engineers in its applied AI division using Anthropic's Claude Code and OpenAI's Codex, citing concerns about inadvertent distillation. Read the tier terms before the first prompt, not after the first incident. If the tier may use your work for future model training, treat your code as training data. Price the tier as a data trade, not a discount. If your code contains customer data, proprietary algorithms, or secrets, the standard tier is the safer default. The answer should be yes or no, not a terms page you skipped.
• Sanity-check the Terminal-Bench and DeepSWE coding-agent benchmark scores against your own failure rate. Pick a refactor that resembles production work: multiple files, tests, and a real failure mode. Run it several times and record where the agent gives up, loops, or produces a wrong patch. Keep your own pass rate on the same kind of refactor, not just a leaderboard number.

Benchmarks are a floor, not a verdict

On Terminal-Bench 2.1, Muse Spark 1.2 inside Muse Code achieved an 82.9% pass@1 score, behind Anthropic's Opus 5 in Claude Code at 86.7% and ahead of OpenAI's GPT-5.6 Terra in Codex at 81.8%, and on DeepSWE 1.1 it achieved 59.3%, third behind Anthropic's Opus 5 at 65.0% and OpenAI's GPT-5.6 Terra at 64.8%. Your own failure rate is the number that matters. If the agent breaks on the same class of task you ship, the leaderboard does not rescue it.