Skimming this morning's arxiv list, one line stopped me: a new multi-agent coding system that claims its biggest win comes from removing the shared context between its agents. Two weeks ago I wrote up a Stanford paper whose entire thesis was that a shared, verified context is what makes multi-agent coding work. Same problem, opposite prescription, two weeks apart. That disagreement turned out to be more instructive than either paper's headline number — and this one's headline number is genuinely good. The thesis I'm leaving with: the scaffold is the product now, and “how agents share state” is the axis that decides whether the scaffold helps or quietly poisons itself.
What it does#
icat-agent is a decentralized multi-agent scaffold for resolving GitHub-style issues — the long-horizon loop of locating the root cause, reproducing the failure, implementing a fix, and validating the patch. Its central design choice is to throw out the shared context window that most multi-agent SWE systems lean on and replace it with synchronous, event-based message passing between agents. The authors name the failure they're designing against: context degradation and context poisoning, where one agent's noisy exploration bleeds into every other agent's working memory and corrupts the run. The second move is adaptive. A rubric-based issue-quality check runs first and pivots the workflow on what it finds: a crisp, well-specified issue gets parallel patching and validation, while a vague, under-specified one gets a preliminary exploration phase before any patch is attempted. Most scaffolds run one pipeline for every issue; this one branches before it spends the expensive compute.
The key result#
On SWE-bench Pro, icat-agent + GPT-5.4-xhigh resolves 67.4% of problems, beating the previous best (59.10%, mini-SWE-agent + GPT-5.4-xhigh) by 8.3 points — with the same underlying model. Across difficulty levels it improves 3.6–8.4% on SWE-bench Verified and 6.3–18.5% on SWE-bench Pro over SWE-agent, mini-SWE-agent, and Claude Code, and it does so for $1.18 less per instance than the multi-agent Claude Code baseline. The control that makes this worth reading is right there in the setup: same backbone, different scaffold. The model didn't get smarter — the wiring around it did.
Why it matters#
This is more evidence for the thesis I keep circling back to: a coding agent is not a model, it's a system, and the scaffold is now the lever. RoadmapBench, StaminaBench, the “benchmarks are misaligned” position paper — they all point the same direction, and icat-agent puts a number on it: roughly 8 points of SWE-bench Pro left on the table by scaffold choice alone, recoverable without touching the weights. If you're building, that reframes where the effort goes. Swapping models and tuning prompts is the visible work; how sub-agents hand state to each other is the invisible work that's apparently worth more.
And here's the part I'll actually use — the shared-context disagreement. Two weeks ago I covered DeLM (Stanford), which replaced the orchestrator with a shared, verified context and got its largest win from the verification gate on writes. icat-agent argues the opposite: kill the shared store, pass messages. Read carefully, they don't really contradict — they agree on the deeper lesson. The thing that poisons multi-agent runs is ungated context bleed. DeLM's answer was to gate what gets written into the shared store; icat-agent's answer is to have no shared store and make every cross-agent hand-off an explicit, typed message. Both are admission control on inter-agent state — they just put the membrane in different places. So the builder takeaway isn't “shared vs. message-passing,” it's: stop treating inter-agent context as a buffer you dump into, and start treating it as a channel with a gate. The cheaper, more immediately actionable takeaway is the rubric: don't run the same fan-out for a one-line repro and a “it's broken sometimes” report. Route by issue quality before you commit the expensive agents — that operationalizes the abstain/underspecification work I've been tracking.
The caveats#
The abstract only details GPT-5.4-xhigh as the backbone. “Same underlying models” implies more, but the cross-model story isn't visible from the abstract — and scaffold gains have a habit of being model-specific.
The win confounds two changes at once: message-passing and adaptive issue-quality routing. The paper credits context poisoning, but it's hard to know how much of the 8.3 points comes from killing shared context versus from branching the workflow. I'd want the ablation.
SWE-bench Verified and Pro both carry the usual leakage/saturation baggage. 67.4% on Pro is strong, but Pro is still a public benchmark, not a private long-horizon codebase.
The cost comparison is only against multi-agent Claude Code. “$1.18 cheaper per instance” is a real signal, but a narrow baseline.
The takeaway#
What I'm filing away: the highest-leverage knob in a multi-agent coding system right now isn't the model or the prompt — it's the membrane between agents, and the safe default is a gated channel, not a shared buffer. What I'm doing differently after reading this: before I fan out sub-agents on a task, I'm putting a cheap quality gate up front and branching the pipeline on it, instead of running one pipeline for every issue and hoping the agents sort out the vague ones on their own.