AI Strategy · Multi-Agent Architecture

Sub-Agents Buy Speed in Code, Accuracy in Knowledge

Multi-agent systems do not purchase the same thing in every domain. In coding they buy speed and context protection — not correctness. In knowledge work the retrieval sub-agent can be the accuracy mechanism itself. The decision rule is simple: where does ground truth live?

By Scott Farrell · LeverageAI

There has been a lot of talk about multi-agent systems. A lot of it is theater. Some of it is useful. The useful part is usually sold as “better AI” — as if bolting on more agents were a universal accuracy upgrade. That is the wrong product description.

What multi-agent actually buys depends on the domain. In coding, the honest read is speed and context protection. In knowledge work, the same architectural move can purchase something rarer: answers that are more correct because they are grounded, not because the model got smarter mid-conversation.

Most people treat multi-agent as a quality upgrade. In coding it is mostly a speed upgrade. In knowledge work it can be a correctness upgrade — when the retrieval sub-agent is the accuracy mechanism.

The honest coding read

In coding, multi-agent frameworks have made agentic systems faster. They have not, by themselves, made AI coding more accurate. A sub-agent goes off and does the menial work — explore the tree, run the suite, draft the patch in an isolated session — and the main agent keeps focus on the bigger picture for longer. That is how longer-running coding agents have been doing a better job: not a wiser model, a cleaner parent context.

Context Engineering names that mechanism without needing a tutorial here: sub-agents as ephemeral sandboxes. Messy intermediate reasoning stays in a disposable window; the parent inherits a clean artifact. Model Barbell and Scatter-Gather Cognition describe the same economic shape — cheap exploration, curated signal back, exploration sludge never dumped into the senior’s attention budget. Those are real engineering wins. They are speed and hygiene wins.

Accuracy in code still lives outside the model conversation. The compiler fails or passes. The test suite is green or red. SWE-bench-style evaluation, whatever its other limits, scores agents against an automated harness — ground truth is not the chat transcript.¹ A sub-agent that runs the build does not invent a new definition of correct; it runs the oracle faster.

That is also why multi-agent enthusiasm often outruns multi-agent results on popular benchmarks. Careful studies of multi-agent LLM systems find that accuracy gains versus strong single-agent baselines are frequently minimal, and that weak or inadequate verification is a major contributor to failure.² Practitioner write-ups make the same structural point from the other direction: agent workflows tend to work better for code generation than for unconstrained reasoning because a compiler or test suite is a hard boundary.³

So the coding column is not “multi-agent is useless.” It is: multi-agent buys throughput and context protection; it does not purchase a new ground truth. Sell it as accuracy and you are misdescribing the product.

The knowledge-sphere flip

Knowledge work has a different physics. There is often no compiler for “what did we learn on that account in 2011?” The failure mode of a lone main agent is not a red test. It is a fluent prior: the generic dull blog post that sounds right and cites nothing your organisation actually holds.

Without a retrieval sub-agent, the main agent answers from what it already believes. With one that can walk the corpus, every load-bearing claim can be grounded in material you own. The retrieval sub-agent is not a nice-to-have optimisation around an already-correct answer. It is the accuracy mechanism.

That is the flip. In coding, multi-agent does not move the oracle. In knowledge work, the second agent can be the path by which the oracle — the corpus — enters the conversation at all. This may be the first domain where multi-agent genuinely improves correctness rather than just throughput.

You are already on the receiving end

This is not a diagram from a conference slide. In a live conversation over a personal or organisational wiki, a wiki_search call between turns is not a database row. On the far side of that tool is a second AI agent — different prompting, quicker access to the data — returning a result shaped for the first agent. That is a knowledge-worker multi-agent pattern, and the human in the chat is already on the receiving end of it.

The edge agent inside the search endpoint is the Scout–Senior Split and Model Barbell running live: a cheap specialist explores the corpus; the senior inherits shaped signal and speaks to the human. The prior canon established that split as a speed and context move. The point of this piece is the domain-dependent payoff: the moment ground truth lives in the corpus rather than in an external test harness, the same split becomes an accuracy architecture.

Shaped signal is where accuracy comes from

Discipline matters. A second agent that dumps raw chunks into the main context is not an accuracy mechanism. It is context pollution with extra steps. Industry context-engineering guidance already pushes the same hygiene: keep structured notes and re-fetchable tool sludge outside the long-lived decision window.⁴

The backend search agent should return typed, shaped signal — references, short gists, pointers, warrants — not a pile of paragraphs impersonating a conclusion. That is the same discipline as demoting RAG to a sensor under multi-axis search: similarity and graph walks and bronze greps can all run behind the scout; the main agent never inherits exploration guts. Scatter-Gather Cognition names the compression idea: curated signal, not raw exploration. The accuracy lives in the shaping — what is admitted into the senior’s attention budget — not in the mere existence of another agent process.

The handoff is a translation

There is a second mechanism hiding in the handoff. The sub-agent speaks corpus-register: wiki pages, edges, document ids, bronze pointers, typed hit ranks. The main agent speaks conversation-register: claims a human can use in the next turn of dialogue. The interface between them is not a pipe. It is a translation one level down the stack.

That is why “just add RAG to the main agent” and “run a scout that returns shaped results” are not the same architecture. The first still asks the conversation model to live in two registers at once. The second specialises the registers and pays for a clean handoff. Conversation as the access interface for organisational IP is the peer claim; the multi-agent move is how the IR gets into the turn without flooding it.

The decision rule

When someone proposes multi-agent for your next system, do not ask how many agents. Ask what the second agent changes about truth.

• If ground truth lives outside the model — tests, compilers, policy engines, human approval gates — multi-agent is a throughput and isolation tool. Use it for speed, parallelism, and context protection. Do not expect the ensemble to invent correctness the oracle does not already define.
• If ground truth lives in the corpus — and the work is to ground claims in material you hold — a retrieval or scout sub-agent is not theater. It is the accuracy path. Build it to return shaped, typed signal; ban raw chunk dumps into the senior context.
• If the task has both (some knowledge work does: CRM fields that are hard facts, plus soft narrative judgment), split the question per claim. Do not let a coding multi-agent story dictate a knowledge architecture, or the reverse.

Agentic theater is multi-agent that never changes the truth path for the task. Useful multi-agent is multi-agent that either accelerates work against an external oracle or supplies the grounding path when the oracle is the corpus.

Closing

Multi-agent is not one product. In code it mostly buys speed and keeps the main agent’s head clear. In knowledge work, done properly, it can buy correctness — because the scout is how the corpus gets into the answer. The Scout–Senior split was always a good speed and context move. The newer claim is simpler and sharper: the same split becomes an accuracy mechanism the moment ground truth moves from an external oracle into the corpus.

Before you fund another swarm, ask one question: where does ground truth live? Answer that, and you will know whether you are buying throughput or correctness — and whether the second agent is architecture or theater.

The placement rule is the deliverable: use it on the next multi-agent proposal that lands on your desk.