Vol. 01 · No. 01
— Field Notes —
June 2026
A Field Note on Architecture

Why Multi-Agent Systems Work

A single large model asked to do four jobs at once will blend them. I think the fix is structural. A bigger model won’t solve it, a smaller contract will.

A single context window asked to act as editor, coder, critic and retriever at the same time will end up doing all four, without ever quite being any of them. The careful editor starts writing code snippets to clarify, the confident coder hedges with editorial disclaimers and the skeptic goes soft because it wrote the draft. The work gets done, but you can see the seams. A multi-agent system splits the work into roles, gives each role its own context and forces clean handoffs, and I think the result is a lot more coherent, on top of being faster.

The agents are the easy part, and the handoffs are where it gets hard.

— closing observation
01 · Failure mode

One brain, four jobs, and the leakage between them

When a single context window has to play four roles at once, the personas leak and each role quietly bends the others. That’s the failure the multi-agent pattern is designed to fix.

The unified brain

The one-context model

One system prompt, supposedly holding four personas in productive tension. In practice you get a hybrid of editor, coder, critic and retriever, each pulling the response in a different direction.

Role 01

Edit the prose

Starts writing code snippets to "clarify"

Role 02

Write the function

Adds hedges and disclaimers mid-function

Role 03

Critique the draft

Goes soft because it "wrote" the draft

Role 04

Retrieve the sources

Tries to sound like the editor again

Figure 1 The single-context failure. One window is asked to hold four personas, and each role bleeds into its neighbours. The output is technically correct but the tone is all over the place.
02 · The pattern

An orchestrator and four specialists, each in their own context

The fix is structural. One orchestrator routes the work, and each specialist runs in a clean context with a system prompt tuned for exactly one job. The seams between them become the handoff protocol, which is explicit, inspectable and correctable.

A typical roster
O
Orchestrator
Routes · Sequences · Validates

Reads the goal, breaks it down, picks the right specialist for each subtask, stitches the results together and decides when to ship. It holds no domain knowledge, only the routing logic and the user-facing persona.

in user goal
out assembled result
R
Reasoner
Plans · Decomposes

Turns vague goals into explicit plans. Quiet and structured, with no opinions about style.

C
Coder
Implements · Tests

Gets a spec and returns a diff. It never sees the original user goal, so it doesn’t know if the project is a startup demo or a production system.

K
Critic
Reviews · Pushes back

Reads a draft as if a stranger wrote it. It doesn’t see the system prompt and doesn’t feel loyal to the author, because its job is to be the skeptic.

Q
Retriever
Searches · Quotes

Takes a question and returns sources with verbatim quotes. No synthesis and no voice, just the receipts.

+
Specialist n
Whatever the job needs

Designer, lawyer, quant, translator. The pattern composes, so you add a specialist, give it a clean context and wire it to the orchestrator.

Figure 2 The five-plus-one pattern. One orchestrator above and a roster of specialists below, each with its own context and its own job. The orchestrator never writes a single line of code or pulls a single source.
03 · The protocol

What actually crosses the seam

The agents are isolated, and the handoff is the only thing that connects them, so in a way the handoff is the system. The minimum viable handoff has three parts, a clear contract, a small payload and a recorded decision.

sequenceDiagram
    autonumber
    participant U as User
    participant O as Orchestrator
    participant R as Reasoner
    participant C as Coder
    participant K as Critic

    U->>O: "build me X"
    activate O
    O->>O: decompose into 3 subtasks
    O->>R: { goal, constraints, format }
    activate R
    R-->>O: { plan, acceptance_criteria }
    deactivate R
    O->>C: { plan, contract, tests }
    activate C
    C-->>O: { diff, run_log }
    deactivate C
    O->>K: { draft, plan, criteria }
    activate K
    K-->>O: { issues[], verdict }
    deactivate K
    alt issues.length > 0
        O->>C: { issues, original_diff }
        C-->>O: { diff_v2 }
        O->>K: re-review
    end
    O-->>U: { final, audit_trail }
    deactivate O
Figure 3 The handoff contract. Each arrow is a typed payload and each box is a clean context. The orchestrator holds no domain knowledge, it only routes, validates and decides when to ship.
04 · Trade-offs

When the pattern wins, when it breaks, and the honest middle

Multi-agent systems aren’t a free lunch. They add latency, cost and a new place for things to fail, which is the seams. The hard part is knowing which problems are worth paying that tax for.

Dimension Single agent Multi-agent
Persona coherence LossRoles blend, so the editor starts coding and the critic goes soft. WinEach specialist runs in its own context. No blending.
Latency & cost WinOne round trip. One bill. Cheap to run. Loss2–5× more model calls, and the coordination tax is real.
Debuggability SplitOne trace to read, but the failure has no clear owner. WinEach step is inspectable. The audit trail is the system.
Failure surface SplitFewer seams, but a bad step poisons everything downstream. LossMore seams. A bad handoff is a new class of bug.
Domain depth SplitDecent at many things, master of none. WinEach specialist can be deeply tuned. Sum of depths > depth of one.
Iteration cost WinChange a system prompt, run again. LossChanging a contract breaks every caller. Refactoring is non-trivial.
Right size of problem Short, single-domain tasks. Quick answers. Anywhere coherence loss is acceptable. Multi-step work that mixes domains. Anywhere persona leak would degrade quality.
Figure 4 Honest accounting. Three wins, three losses, two splits and one judgment call. Neither column wins outright, they’re just shaped differently.
Closing observation

Build the seams first, and the agents come after

A multi-agent system is a small, opinionated protocol between personas. If the contract between them is sloppy, the system will produce confident garbage with extra steps. If the contract is sharp, with explicit inputs, explicit outputs and an explicit decision rule for when the work is bad, the system can outperform any single agent on the same problem. That’s because each agent gets to be exactly one thing.

The pattern is older than the tooling. Print shops, military staffs, hospital triage and restaurant kitchens have all been running multi-agent systems for decades. What’s new is that we can now write the seams in plain text and the agents in plain code, and then watch the whole thing work in a browser tab. Not bad at all.

— end —

Why Multi-Agent Systems Work · A Field Note Set in Shadows Into Light Two & Cause

← Back to all posts