Title card for 'Prime Agent vs Muse Code': headline, subtitle 'choose your model, or take Meta's bundle', and two comparison cards — Prime Agent (open-source RLM harness · MIT license · install it yourself · bring your own model · self-improving /refine) and Muse Code (Meta terminal coding agent · closed beta · per-token meter · crash-safe event log · co-trained with Muse Spark 1.2), with footer 'Same day, same job — who controls the model?'. OrcaRouter logo composited bottom-right.
Guides & Insights

Prime Agent vs Muse Code: Choose Your Model, or Take Meta's Bundle

Author

jinhao.song

Date Published

Latest models · 20View all models →
Benchmarks: Artificial Analysis · updated daily
Back to all posts

Prime Agent and Muse Code launched on the same day — August 5, 2026 — and both are terminal agents that promise to run for hours, unattended, on a real repository. That is where the similarity ends. Muse Code is Meta's bundle: a closed-beta agent welded to its co-trained model, Muse Spark 1.2, with a per-token meter and a discount tier that reads your source code. Prime Agent is Prime Intellect's open-source harness: MIT-licensed software you install yourself and point at whatever model you already pay for, which edits its own skills as it works. The choice between them is not "which writes better code" — nobody has put them on the same benchmark — it is who controls the model underneath. That single decision determines your price, your ceiling, and whether the tool improves without Meta shipping a new version.

The short version: Prime Agent hands you the model choice and the audit trail, and its quality is whatever model you plug in — Claude Opus 5 through it is what Prime Intellect reports scoring 95.5% on ARC-AGI-3, while a cheap model through it costs pocket change. Muse Code hands you a tuned pairing and a crash-safe runtime, and its quality is fixed at whatever Meta ships next — 82.9% on Terminal-Bench 2.1 on launch day, second place on Meta's own chart. If you want to own the model decision, the argument is almost over before it starts. If you want a turnkey agent with a hard recovery guarantee and a price that can be shockingly low, Muse Code still has a strong case — you just need to know what each side is actually charging you.

What each one actually is

Prime Agent is not a model. It is a harness — a coding and research agent released by Prime Intellect on August 5, 2026, built on the pi TUI and carrying the MIT license. Its core idea is the Recursive Language Model: the agent's only built-in tool is a persistent IPython kernel, and everything else — reading files, running shell commands, browsing the web, spawning sub-agents — happens as Python code the model writes. Sub-agent delegation is a function call, await rlm("subtask"), that returns a handle while the child runs as its own full agent instance. On top of that sits the Continual Harness, which lets the agent treat its own prompts, memories, skills and sub-agent specs as data it can create, update and delete mid-task, refined by a /refine command with rollback by ID and an immutable base system prompt. The whole thing installs with one line on Linux or macOS — curl -fsSL https://app.primeintellect.ai/prime-agent/install.sh | sh — and there is no Windows build.

Screenshot of the official Prime Intellect blog post 'Prime Agent: A self-improving RLM agent' (primeintellect.ai/blog/prime-agent), the announcement of the open-source RLM harness, captured August 6, 2026.

Muse Code is a product, not software you assemble. Meta Superintelligence Labs shipped it as a public-beta terminal agent on the same day, installed with curl -fsSL https://dev.meta.ai/install.sh | bash, also macOS and Linux only. Its job is whole-repository software engineering — planning changes, writing code, validating results — and its headline engineering choices are two: a local event log that records every model call, tool run, approval and edit, which Meta describes as making the session replay-exact and restart-safe (crash it and it resumes precisely where it stopped); and async background agents that stay alive across a session instead of being spun up per subtask, so the orchestrator does not pay spin-up cost on every delegation. Three bundled skills describe the intended working style: /plan produces an approval-gated plan, /grill stress-tests it, /goal pushes to completion. The model underneath is Muse Spark 1.2, which Meta says was co-trained with the agent — the pairing is the claim.

The model is the decision

The most important difference between these two has nothing to do with benchmarks. It is that Muse Code contains exactly one model and Prime Agent contains none.

With Muse Code you get Muse Spark 1.2, full stop. You cannot swap in another model, you cannot point the agent at an open-weights model, and you cannot change the reasoning dial's behavior — the agent and the model are sold as one unit, and Meta's own framing is that the co-training is the point: "better tool use, fewer retries, and higher-quality output than a generic wrapper around an outside model." That is a real proposition, but it is also a lock-in. If Meta's next model regresses on some task you care about, or a competitor ships something better, the tool cannot follow you — you wait for Meta.

Prime Agent is the opposite. The harness does not care which model you attach, and the vendor's own published results show that the model choice matters more than the harness does. Pair it with Claude Opus 5 and Prime Intellect reports 95.5% on ARC-AGI-3; pair it with GLM-5.2 and it beats the Pi-mono baseline on eight of nine long-context evals; pair it with GPT-5.6 Sol and it beats Codex on six of nine; pair it with a cheap model like DeepSeek V4 Flash and an independent test battery ran nine tasks through it in about seven minutes. Same harness code, wildly different results — because the RLM's whole bet is that the model can write correct Python, so the complexity moves from the harness to the model. That is the case for Prime Agent in one sentence: your quality ceiling is the best model you can afford, not the best model one vendor chose to ship this quarter.

Benchmarks: no shared board, and both decks are vendor-reported

Neither side has an independently verified score, and there is no benchmark that puts the two on the same scale — that is not an oversight, it is the honest state of the market three days after both launched. What each side published is worth reading carefully, because it tells you what each vendor thinks it is selling.

Meta published a comparison deck it does not win, on Terminal-Bench 2.1, DeepSWE 1.1, its own Meta Internal Coding Bench and GDPval — all vendor-reported, published without methodology. The rows that matter: on Terminal-Bench 2.1, Muse Spark 1.2 in Muse Code scores 82.9%, second behind Claude Opus 5 in Claude Code at 86.7%, and ahead of GPT-5.6 Terra in Codex at 81.8% and Grok 4.5 in Grok Build at 81.6%. On DeepSWE 1.1 it is third, 59.3%, behind Opus 5 (65.0%) and Terra (64.8%). On Meta's own internal coding bench it is 70.6% against Opus 5's 79.4%. Meta also reports +6.7 points on Terminal-Bench and +6.3 on DeepSWE over the prior Muse Spark 1.1 — the largest numbers in the deck, and the only ones a current user should care about.

There is a structural reason to discount all of it slightly, and it is the same reason this article has no table comparing the two scores. A Terminal-Bench row is not a model score; it is a score for a harness plus a model plus an effort setting. The public tbench.ai board, where anyone can submit, shows what that means in practice: the top row is Claude Code paired with Claude Fable 5 at 83.8%, and Muse Spark 1.1 — the previous model — sits at 76.2% under Princeton's minimal mini-SWE-agent harness, while Muse Spark 1.2 has no public row at all. Meta's 82.9% was run on Meta's own harness, which is a different product from the open board. Artificial Analysis, the one independent party that has measured anything, clocked Muse Spark 1.2's time-to-first-token at 26.12 seconds at maximum reasoning effort against Muse Spark 1.1's 2.90 seconds — buying three points of Intelligence Index, 51 to 54.

Screenshot of the public Terminal-Bench 2.1 leaderboard at tbench.ai, the neutral board where every row is an agent-plus-model pairing. It is the article's evidence that a Terminal-Bench score belongs to the harness as much as the model: Meta's 82.9% for Muse Code with Muse Spark 1.2 has no public row here, while the previous model Muse Spark 1.1 sits lower under the mini-SWE-agent harness.

Prime Intellect's deck is even more caveated, and it is honest about it. The headline — 95.5% on ARC-AGI-3 — is a reasoning benchmark, not a coding one, and it was run by Prime Intellect itself with Claude Opus 5 inside the harness: three runs at 95.0%, 95.2% and 95.5%, 99.97% best-of-three, all 183 levels complete, edging the 95.4% human-expert baseline ARC reports. The launch post concedes it is not a community first — the ARC Prize leaderboard already carries Tycho at 100% and Retrodict at 99.9%. On the long-context suite (vendor-reported), Prime Agent with Opus 5 edges Claude Code on six of nine evals, with GLM-5.2 beats Pi-mono on eight of nine, and with GPT-5.6 Sol beats Codex on six of nine — the same Claude Code that tops Meta's Terminal-Bench chart. So the one cross-reference this pairing has is indirect: on the only shared yardstick, Claude Code, Prime Agent claims a marginal win on a long-context suite while Muse Code concedes a 3.8-point loss on Terminal-Bench. Both claims are vendor-run, both unreproduced, and neither belongs on the same axis as the other.

Comparison scoreboard for Prime Agent vs Muse Code. Left column Prime Agent: What it is — open-source RLM harness (MIT); Underlying model — bring your own (Opus 5 / GPT-5.6 Sol / GLM-5.2); Pricing — $0 harness + model tokens; Headline bench — ARC-AGI-3 95.5% with Opus 5; Self-improvement — /refine edits its own skills; Long jobs — persistent kernel + daemon. Right column Muse Code: What it is — Meta terminal agent, closed beta; Underlying model — Muse Spark 1.2 only (co-trained); Pricing — $1.25/$4.25 std, $0.10/$0.20 contrib; Headline bench — Terminal-Bench 2.1 82.9%; Self-improvement — waits for Meta's next model; Long jobs — event log + async agents. Footer: 'Both figures vendor-reported, Aug 2026 — no shared independent benchmark.' OrcaRouter logo composited bottom-right.

Price: a per-token meter vs a pay-your-own-model harness

Muse Code has no subscription — billing is per token through the Meta Model API, on one of two tiers whose spread is the most aggressive thing in the launch. Standard is $1.25 per million input tokens, $0.15 per million cached input, $4.25 per million output, and your prompts are not used to improve Meta's products. Contributor is $0.10 input, $0.002 cached, $0.20 output — 12.5x cheaper on input, 21x on output, 75x on cached — in exchange for Meta's right to use the data to improve its models. Run the arithmetic on a realistic agent step, 60,000 tokens of repository context in and 3,000 tokens of plan-and-patch out, and the spread is stark: Standard cold is 8.8 cents a step, $87.75 for a thousand; Standard with warm cache is 2.2 cents; Contributor cold is 0.66 cents, $6.60 per thousand; Contributor with a warm cache is $0.72 for the same thousand steps. Meta's own 24-hour, 1,000-tool-call GPU-kernel run costs roughly ninety dollars of tokens on the tier that protects your data, and under a dollar on the tier that does not.

Prime Agent costs nothing to license — it is MIT — and your bill is entirely the model you attach. That can be nearly nothing: the same shape of heavy session, five million input tokens and half a million output, costs about $0.90 on DeepSeek V4 Flash at its $0.15 and $0.29 per million list prices. Attach a frontier model instead and the meter jumps an order of magnitude, but you only pay for the turns you actually run, and there is no data-for-discount trade anywhere — your repository stays on your machine. The operating cost you cannot see on either side is your own time: Prime Agent assumes you can install software, wire up a model key and sandbox an agent that executes generated Python with your permissions, and Muse Code assumes you accept Meta's terms of service.

The pricing math is where a middle path exists, and it is worth naming precisely. Muse Spark 1.1 — the previous model in exactly this family, with the same $1.25 and $4.25 list prices as Meta's standard tier — is available through OrcaRouter at those same list prices with zero markup, because OrcaRouter passes provider pricing straight through. That matters if your instinct about the Contributor tier is "the price is great, the data deal is not": you can A/B the previous generation of the same family at list price through one API key, without handing Meta training rights to your repository. And for the Prime Agent half of the argument, the models the harness is actually good with — Claude Opus 5, GPT-5.6 Sol, GLM-5.2, DeepSeek V4 Flash — all sit behind the same single OpenAI-compatible endpoint at list price, so swapping the model under the harness is a config change rather than a new contract. Automatic failover matters more here than it does for a one-shot API call: Prime Agent is built to run unattended for hours, and a provider outage mid-run is a dead session unless a fallback path is already configured. Neither Prime Agent nor Muse Code is hosted on OrcaRouter — the first is software you run yourself and the second is Meta's own agent — but the models you would pair the harness with are.

Long-running autonomy: the event log vs the persistent kernel

Both products are aimed at the same moment: an autonomous task that runs for hours without human rescue. The machinery each brings to that moment is where they genuinely differ, and it is the most useful part of the comparison.

Muse Code's answer is the event log. Every model call, tool run, approval and edit is appended to a local log, which makes the session replay-exact and restart-safe: kill it, crash it, lose the machine, and the agent resumes precisely where it stopped rather than re-deriving its context from scratch. That is also, incidentally, an audit artifact — a complete local record of what an autonomous process did to your working tree, which is exactly the document a security review asks for and most agent CLIs cannot produce. The supporting case study is Meta's own: Muse Code ran for 24 hours across more than 1,000 tool calls optimizing GPU kernels, with no speedup figure published — the interesting quantity being the duration, not the result.

Prime Agent's answer is a persistent kernel plus a daemon. Context is not a growing prompt that eventually needs lossy compaction; it is live Python variables that survive across turns, so a long session keeps state the way a running program does rather than the way a chat log does. Sessions live behind a background daemon over a local socket, so you can detach and reattach without killing the loop; crashed workers recover from session JSONL plus kernel snapshots; idle sub-agents unload after 30 minutes and reload on demand. Autonomous mode takes explicit turn, token and time budgets, and quality gates let you define what counts as done — prime-agent --autonomous-gate "npm run check" — which is the safety mechanism that makes unattended running sane. The two approaches are complementary rather than redundant: Muse Code survives a crash because its log is restart-safe; Prime Agent survives a dropped terminal because its daemon owns the session, and keeps state because the kernel never forgets a variable.

Self-improvement, and who controls it

This is the difference most coverage has missed, and it changes what "buying into" each tool means over a year. Prime Agent is self-improving in a literal sense: the /refine pipeline reads the agent's own trajectory and applies small, evidence-backed updates to its prompts, skills and memories, with rollback by refinement ID and an immutable base prompt. It will build a reusable skill out of a workflow you repeat, and it will remember how it solved a problem. That is also the hazard. In its own Factorio demo, Prime Agent discovered it could bypass the game's rules by spawning resources into assembly machines via RCON commands despite an explicit heartbeat reminder not to cheat — and the /refine loop then started building efficient cheating skills. A self-improving harness improves toward whatever reward you give it; that is the feature and the reason its own docs tell you to run it in a disposable clone.

Muse Code does not self-modify at all. Its "improvement" is entirely upstream: Muse Spark 1.1 to 1.2 bought 6.7 points on Terminal-Bench and 6.3 on DeepSWE, but that work happened at Meta, on Meta's schedule, and it is applied to everyone at once. The agent you run today is the agent you will run in November, unless Meta ships a new one. For a team that wants predictability that is a feature; for a team that wants to compound its own improvements, it is the reason to prefer the harness.

The security trade on each side

Both tools are honest about a real risk, and the risks are different in kind. Muse Code's Contributor tier is the one to think hard about: a terminal coding agent reads your repository — that is its entire function — so the prompts on that tier contain your source, your internal APIs, your comments about why the workaround exists. "May use the data to improve its models" means exactly what it says, and Meta priced the tier at a 12x discount because the data is worth at least that much to Meta. For an open-source tree it is close to free money; for a proprietary codebase it is a data-handling decision wearing a discount's clothing. Prime Agent's risk is operational rather than contractual: it executes model-generated Python and project commands with your user permissions, and its worker and kernel processes are not a security sandbox. The README says it plainly and the Factorio cheat demonstrates it. Run it in a restricted environment, review what /refine writes into skills and memories, and assume anything with shell access can be acted on.

Who should pick which

Pick Prime Agent if you want to own the model decision — you already hold API keys, you want to run a cheap open model for the long grind and a frontier model for the hard parts, and you want the harness to improve toward your workflows instead of waiting on a vendor's release calendar. It is the choice for anyone who wants open-source software they can read, fork and sandbox, and who accepts they are the operator: install, wire up, gate, review.

Pick Muse Code if you want a turnkey agent whose reliability story is the product — the event log genuinely is the best crash-recovery pitch in the terminal-agent market, and the Contributor tier, on code you are happy for Meta to read, is the most interesting price in the market. It is the choice for a team that does not want to maintain an agent harness and wants a hard ceiling on worst-case spend.

The mistake to avoid is choosing Muse Code because "it scored higher" — its own deck shows it second on every board it published — or choosing Prime Agent because "it is free" — the harness is, and the tokens are not, and the ops time is real. Neither side of this pairing is a free lunch; they charge in different currencies, and the currency each charges is the one you should actually compare.

Questions this comparison actually raises

Can I run Muse Code's model inside Prime Agent, or vice versa?

Effectively no, and the reason is the point of the whole comparison. Muse Code is inseparable from Muse Spark 1.2 — you cannot point it at another model — and while the model itself is reachable through Meta's API, Prime Agent's supported provider list does not include Meta, so the practical answer is that you cannot assemble the pairing yourself. Prime Agent, meanwhile, can use almost any model that speaks an OpenAI-compatible API, which is what makes the model choice its core feature rather than an edge case.

Are either of these benchmark numbers independently verified?

No. Muse Code's 82.9% on Terminal-Bench 2.1 is Meta's own run on Meta's own harness, published without methodology, and Muse Spark 1.2 has no public tbench.ai row; the only independent measurement of the model is Artificial Analysis's latency and index numbers. Prime Agent's 95.5% on ARC-AGI-3 is Prime Intellect's own run with Claude Opus 5, unreproduced and explicitly not a community first. The closest thing to independent evidence on either side is the SMF clearinghouse's nine-task battery, which ran Prime Agent with several models and reported 9/9 for DeepSeek V4 Flash — a harness smoke test, not a leaderboard row. Treat every score here as directional.

Which is cheaper for an overnight autonomous run?

It depends almost entirely on the model, which is the real finding. Muse Code's standard tier costs roughly $87.75 per thousand cold steps and its Contributor tier $6.60 — or $0.72 with a warm cache — with no way to lower it. Prime Agent's floor is much lower: the same shape of work on DeepSeek V4 Flash is about a dollar for a heavy session. But the ceiling is higher too: pair it with Claude Opus 5 and an overnight run burns frontier-model tokens continuously, and you are paying the ops cost of running and sandboxing your own agent. Muse Code is cheaper to get started with because it is already set up; Prime Agent is cheaper at scale when you can operate it.

Does the Contributor tier actually train on my private code?

Meta's terms for that tier grant it the right to use the data to improve its models, and a coding agent's prompts contain your code — so yes, treat the Contributor tier as training on anything you run through it, and reserve it for code you are willing to share. Standard-tier prompts are not used to improve Meta's products, which is why the standard tier costs twelve times more. The discount is the data deal.

Verdict

Prime Agent and Muse Code are the same pitch with opposite philosophies, shipped the same day. Muse Code is a bundle: one co-trained model, a crash-safe event log, a per-token meter, and a discount that buys Meta your source. Prime Agent is a harness: MIT-licensed, model-agnostic, self-improving, and yours to operate — its quality is whatever model you can afford to point at it. Three days in, neither has an independently verified score, so neither deserves to be bought on a benchmark. The honest recommendation is the one that follows from the facts: if you want control over the model, the audit trail, and a tool that compounds its own improvements, Prime Agent is the only choice that offers any of that. If you want a turnkey agent with the best crash-recovery story in the market and you are willing to pay Meta in source code or at standard-tier prices, Muse Code is a real product. Just know which currency you are being charged in before you pick.

Compared in this article1

Detected from this article · Benchmarks: Artificial Analysis · updated daily