Two Agent Harnesses Shipped in 48 Hours — and They Make Opposite Bets
August 7, 2026
11 min read
AI & Technology
August 7, 2026
11 min read
On August 5, Meta released Muse Code — a terminal coding agent running on Muse Spark 1.2, a model it trained alongside the agent itself. On August 6, Prime Intellect open-sourced Prime Agent under MIT, a harness designed to run any model you point it at, which scored 95.5% on ARC-AGI-3 with Opus 5 behind it.
Neither release is fundamentally about a model. Both are about the scaffolding wrapped around one: how context is managed, how sub-agents get spawned, what survives a crash, what the agent is allowed to change about itself mid-task. That is a shift worth naming. For two years the interesting releases were checkpoints, and the founder's question was which model to route to. These two say the model is no longer where the remaining gains are.
What makes the pair genuinely useful is that they agree on the premise and disagree completely on the conclusion. One says the harness is portable and should be owned by you. The other says the harness only works when the model was trained inside it, so it should be owned by the lab. You are going to have to pick a side, so it is worth understanding the argument.
Prime Agent is built on two ideas, and both are unusual enough to be worth stating plainly.
The first is the Recursive Language Model. Instead of context being a window that fills up and gets truncated, context is a variable inside a persistent IPython kernel. The model writes code that operates on its own history — searching it, slicing it, summarising parts of it — rather than being handed a pre-assembled prompt. Sub-agent delegation is not a special orchestration layer; it is a function call in that same REPL. If you have ever written a supervisor node in LangGraph, this is the same problem solved one level down: the agent programs its own delegation instead of you wiring it.
The second is the Continual Harness. Prompts, skills, memory and sub-agent definitions are treated as state the agent can create, read, update and delete from inside its own run. The /refine command analyses the trajectory so far and proposes targeted edits to that state — planned in the background so it does not block, applied at turn boundaries, evidence-backed, and reversible through a rollback history. The agent is, in a limited and audited sense, rewriting its own scaffolding while it works.
The headline number: 95.5% RHAE Best@1 on ARC-AGI-3 with Opus 5, against ARC's reported human-expert baseline of 95.4%. Runs came in at 95.0, 95.2 and 95.5, so the result is stable rather than a lucky sample. Best@3 reaches 99.97% with all 183 of 183 levels completed. Prime Intellect also reports better token efficiency than the models' native harnesses, which matters more than the score does.
The claim that should get your attention is not the ARC number, though. It is the comparison underneath it: Prime Agent running GLM-5.2 was competitive with or better than Claude Code running Opus 5 and Codex running GPT-5.6 Sol across a set of long-context benchmarks — OOLONG, OOLONG-Pairs, OBLIQ-Bench, LongBenchPro and ManyIH. If that holds up independently, it means a mid-tier open model in a better harness can match a frontier model in the harness its own lab built. That is a much larger statement than one benchmark record.
The demos, for calibration
Prime Agent produced working Rust emulators for the SEGA Genesis and Game Boy Color without reference code, and reached a 100K+ production score in Factorio within hours. Read these the way you should read every launch demo — as evidence the system can sustain very long coherent work, not as evidence about your codebase. Emulators and factory games have something your product does not: a fast, unambiguous, automatic signal for whether the last change was correct.
Meta's release is less conceptually novel and considerably more operationally serious. Muse Code is a terminal agent in beta for macOS and Linux, installed with one shell command, running Muse Spark 1.2 through Muse Code or the Meta Model API. There are no downloadable weights.
Three design decisions are worth stealing regardless of whether you ever run it.
The append-only event log. Every model call, tool run, approval and edit is appended to a local log, which makes the runtime replay-exact and restart-safe. When the agent crashes forty minutes into a task, it resumes where it stopped instead of starting over. This is the single most underrated property in the release. Anyone who has run long agent sessions in production knows that the failure that hurts is not a wrong answer — it is losing thirty minutes of accumulated state to a timeout, and having no way to reconstruct what the agent believed at the moment it went wrong.
Persistent background agents. Rather than spawning a fresh sub-agent per task, Muse Code keeps a set of async background agents alive across the session. The stated reason is avoiding redundant information gathering — the second sub-agent does not re-read the repository the first one just read. If your orchestration spawns a clean agent per step, you are paying that re-discovery tax on every step, and it compounds.
Approval-gated planning as a default skill. Muse Code ships with /plan to turn a task into a plan you approve before execution, /grill to stress-test that plan until it holds, and /goal to drive toward completion. Putting an adversarial pass over the plan before any code is written is a cheap intervention most teams skip.
Meta evaluated on Terminal-Bench 2.1 (89 tasks, pass@1 over five attempts), DeepSWE v1.1 (113 tasks across 91 repositories and five languages) and an internal bench of 440 tasks derived from real pull requests, comparing against Grok 4.5, Claude Opus 5, GPT-5.6 Terra, Gemini 3.6 Flash and Kimi K3. I have not been able to verify the published Muse Spark 1.2 figures from a primary source — the numbers live in chart images on Meta's post — so I am not going to quote them. For scale: Muse Spark 1.1 scored 80.0 on Terminal-Bench 2.1, and Qwen3.8-Max reported 86.6 on the same benchmark last week. The claim that is easier to evaluate is the internal run where the model optimised GPU kernels across more than 1,000 tool calls and up to 24 hours of continuous work. Duration at that scale is a harness property, not a model property.
Here is the part that makes this pair interesting rather than just busy.
Prime Intellect is unusually candid about its own limitation. Their write-up notes friction when running Prime Agent with various models, and states plainly that no model has been trained around Prime Agent or its core feature set. The 95.5% comes from a frontier model doing something it was never specifically trained to do, inside a harness it has never seen. They are treating the remaining friction as the gap between where they are and where the approach could go.
Meta closed exactly that gap, in the other direction. Muse Spark 1.2 was trained alongside the tool. The model and the harness were developed as one artefact, which is why Meta can promise 24-hour sessions and replay-exact recovery — the model has been shaped to behave well inside that specific runtime.
So both parties agree on the substantive technical point: model and harness are coupled, and the coupling is where the performance is. They disagree on who gets to own the coupling. Prime Intellect's bet is that an open, portable, self-modifying harness accrues improvements faster than any single lab can, and that models will eventually be trained toward harnesses like it. Meta's bet is that co-training is a moat, and that the best agent will always be the one whose model was raised inside it.
Why this matters to you specifically
If the portable bet wins, your agent scaffolding is a durable asset and model swaps stay cheap — the thing to invest in is your harness. If the co-trained bet wins, your scaffolding is a temporary bridge to whichever lab is currently ahead, and the thing to invest in is the ability to migrate. These lead to different engineering decisions this quarter, which is why it is worth having a view rather than waiting for the answer.
Four caveats, because the number is going to be quoted a great deal this week without them.
Most teams reading this should not switch harnesses this week. But almost every team should steal from both.
/grill pattern — generate a plan, then attack it before executing — catches the class of failure where the agent does forty correct steps toward a wrong objective. Reviewing the diff at the end cannot catch that.Last week I wrote that Qwen3.8-Max's benchmark gaps were not in raw intelligence — GPQA Diamond at 92.6 is frontier-class — but in long-horizon agentic work, where a model has to hold a plan across forty steps and recover from its own mistakes. This week two labs shipped releases that attack precisely that gap, and neither attacked it by making the model smarter.
That is the pattern worth carrying forward. The remaining distance between an impressive demo and a system that survives a real workload is being closed by engineering: durable state, resumability, context management, delegation that does not lose what it learned, a plan someone argued with before execution. None of that arrives in a checkpoint. All of it is buildable by a competent team, which means it is available to you, and it means the advantage does not expire when the next model ships.
The uncomfortable implication is that if your agent is underperforming, the model is probably not your problem. Swapping checkpoints is the easiest experiment available and therefore the one most teams run first. It is rarely the one that moves the number. Build the log, fix the delegation, argue with the plan — then go shopping for a model.
