The Coordination Problem: Why Multi-Agent AI Systems Break at Scale
Single agents getting smarter does not make multi-agent systems more coherent. The failure is architectural, and fixing it requires a layer that does not exist yet.
Here is the failure mode that started this line of research.
We were running three agents in parallel: one scraping LinkedIn for competitive intel, one monitoring X for product announcements from the same companies, one compiling a weekly competitor report. Each agent had its own context, its own tools, its own instructions. Each was behaving correctly according to its local task.
The LinkedIn agent found that a competitor had just hired a VP of Engineering — a signal they were scaling their product team. The X agent, independently tracking the same company's CEO, had found a thread suggesting a pivot to enterprise. The report agent, with no live connection to either of those findings, was writing a summary that characterized this competitor as consumer-focused and early-stage.
No single agent failed. Every agent was doing exactly what it was told. The system produced a report that contradicted itself in three different ways, and none of those contradictions were visible until a human read the final output.
This is the coordination problem. It is not about agent intelligence. It is about what happens when agents operate without a shared model of reality.
The Isolation Architecture and Why It Breaks
Almost all current multi-agent frameworks are built around isolation: each agent gets a context window, a tool set, and a task definition. Agents communicate by writing outputs that other agents read as inputs. An orchestrator — often a separate LLM call or a human — routes messages between agents and assembles results.
This works for sequential pipelines where order of operations is fixed and outputs are independent. It breaks for anything involving parallel execution, shared targets, or state that changes during the run.
The problem is information latency. In the example above, the LinkedIn agent's discovery that the competitor was scaling its engineering team was real information that should have updated the report agent's model of that company. But in an isolation architecture, there is no mechanism for a live discovery in one agent to propagate to another agent mid-execution. The orchestrator only sees outputs, and only after each agent has finished.
You can work around this with shorter task cycles, more frequent synchronization points, or more explicit message passing. But you are fighting the architecture. The isolation model was designed to keep agents from interfering with each other. What you actually need is for agents to usefully share state — which is a different design entirely.
Intent as a First-Class Object
The insight that changed how we think about this: intent needs to be a database primitive, not a message.
In most systems, the "goal" of a multi-agent task exists only in the orchestrator's prompt. Each agent receives its local task definition. But the shared intent — what the system as a whole is trying to achieve — is implicit. There is no queryable, updateable object that represents it.
What if there were? What if every agent, before acting, could read a live object that said: here is what we are trying to do, here is what has already been discovered, here are the constraints we are operating under, here are the conflicts that have been flagged?
This is what Grid models. The intent object is not a prompt — it is a live, structured, queryable record of what the system knows and what it is trying to do. Agents read from it before acting and write proposed state changes back to it. The system checks those proposals against the current state and against any active mandates before allowing them to propagate.
In the example above, when the LinkedIn agent discovers the VP of Engineering hire, it writes that to the shared state. The report agent, reading shared state before writing its summary, now has access to that discovery. The conflict that previously only became visible at final output is caught at write time.
Mandates, Not Capabilities
One finding that genuinely surprised us: the most reliable lever for making multi-agent systems coherent is not improving individual agent capability — it is being explicit about what the system is not allowed to do.
Mandates are constraints attached to an intent object. They travel with the task. Every agent in the network can read them. They are enforced at the coordination layer, not delegated to individual agents to remember.
This matters more than it sounds. When you give a capability to an agent — "you can post to X" — you are trusting that the agent will apply good judgment about when to use it. When you encode a mandate — "no public posting without human approval" — that constraint is not in the agent's judgment. It is in the coordination layer. The agent cannot violate it even if its local reasoning says it should.
Capability-first design asks: what can agents do? Mandate-first design asks: what can they not do, and who decides? We think the second question is more tractable and produces more predictable systems.
The Hard Case: Human-AI Coordination
Agent-agent coordination is tractable. The agents have defined interfaces, deterministic outputs, and explicit task boundaries. You can model their interactions formally.
Human-AI coordination is much harder, and it is the case that matters most in production. Humans update their intent continuously and rarely communicate those updates explicitly. A founder who says "monitor this competitor" on Monday may have a completely different understanding of what that means by Thursday, without ever telling the agent.
The coordination layer for human-AI systems cannot just model agent intent. It has to model human intent — including intent that has been implied but not stated, updated but not communicated, and changed by external events that the human has processed but not articulated.
We do not have a clean solution to this. Our current approach is to make the intent object writable by humans at any point — a lightweight interface for updating shared state directly rather than re-prompting the orchestrator. But the deeper problem of inferring unstated intent changes is still open.
Where Coordination Sits in the Stack
Our prediction: the coordination layer becomes as fundamental to multi-agent AI as the operating system is to software. Not because agents need to be managed — but because coherence at the system level requires infrastructure that no individual agent can provide for itself.
This is not a model problem. GPT-5 will not solve it. Smarter agents fail at coordination in new ways — they produce more sophisticated local reasoning that is even harder to reconcile with other agents' sophisticated local reasoning. The failure mode gets more expensive as the agents get more capable, which is the opposite of what you want.
Grid is our current answer. It is early, and there are things we have not figured out — especially on the human-AI side. But the problem is real, the isolation architecture has hard limits, and the coordination layer is where the work is.
If you are hitting coordination failures in multi-agent systems — contradictory outputs, race conditions on shared resources, agents working at cross-purposes — we want to hear the specific failure mode. rahul@ollie-labs.com