When your agents don't know what your other agents have learned

Most teams running multiple AI agents have solved the orchestration problem. You know how to route tasks, set up pipelines, run agents in sequence or parallel. The part that breaks at scale isn't orchestration. It's context.

Agent A runs a research task and surfaces three constraints that matter. Agent B runs the implementation task and violates one of the constraints — not because it was careless, but because it never had access to what Agent A learned. Agent A's context window closed; the constraints it found went with it.

This happens constantly and mostly invisibly. Each agent does exactly what it was designed to do. The output of the fleet is still incoherent because the agents don't share a persistent knowledge layer.

The shape of the fragmentation problem

Context fragmentation shows up in several forms.

Session boundary evaporation. Agents derive things during a session — constraints, tradeoffs, research findings — that are relevant to future sessions. Without a persistent memory layer, everything derived in a session evaporates when the session ends. The next session starts cold.

Cross-agent isolation. Even with memory within a single agent's sessions, memory is typically scoped to that agent. What your research agent learned about the codebase doesn't automatically reach your implementation agent. What your customer context agent loaded from CRM history doesn't reach your outreach agent. The isolation is a product of how memory tools have historically been designed — user_id or session scoped, not fleet-scoped.

Contradictory derived knowledge. Two agents working in parallel on related tasks can derive contradictory conclusions — not because they were given contradictory inputs, but because they explored different parts of the problem space and drew different inferences. Without a mechanism to surface and resolve the contradiction, both conclusions quietly persist in the system and shape future outputs in conflicting directions.

What a shared substrate changes

When agents share a memory substrate, what one agent learns becomes available to others — deliberately, not by accident.

A research agent that surfaces a critical constraint can log it explicitly or have it captured by the passive capture layer. An implementation agent starting work on the same area loads that constraint at session init. It doesn't re-derive it; it doesn't violate it. The constraint is part of its context from the start.

This is the coordination memory pattern. The agents still run independently — different models, different schedules, different tool sets. What keeps them coherent isn't a coordinator that synchronizes them at runtime. It's a shared memory layer that makes each agent's prior conclusions available as context for the next.

Conflict detection at the fleet level

The parallel-agent contradiction problem — two agents deriving conflicting conclusions — is addressed directly by conflict detection running at the memory layer. When two memories covering the same topic contradict each other, the system flags the conflict for resolution rather than silently maintaining both.

In a fleet context, this surfaces things like: Agent A logged "deployment should go through the staging environment before prod." Agent B, working a different task, logged "the staging environment is deprecated; deploy direct to prod." Both logged by legitimate agents, both confident. The system identifies the contradiction; a human or a supervisor agent resolves it. The resolved version becomes the memory that governs the fleet; the superseded version is retired with attribution.

Without conflict detection, both memories persist in the layer, and different agents load different versions of the truth depending on which one surfaces first in their retrieval. The fleet behaves inconsistently — not obviously broken, just inconsistent in ways that are hard to trace.

What inference from absence adds

The context fragmentation problem has a subtler form: agents making assumptions about areas where they have no signal, rather than flagging that the signal is missing.

Inference from Absence is a mechanism for identifying what's not in the memory layer. For a given task, what context would you expect to be available that isn't? What constraint decisions should have been made about this area but haven't been logged? What questions would a knowledgeable agent ask that currently have no available answer?

This surfaces the gaps proactively rather than waiting for an agent to derive something wrong in the absence of context. A supervisor agent reviewing the task queue can see that the implementation task for module X has no logged constraints, no prior decisions, and no customer signals — and can either request that context be gathered first, or flag the task as running with known gaps.

The practical picture

Running eight agents across two projects without having them step on each other requires:

• Session-init recall so each agent starts with the relevant context from prior sessions and other agents
• Passive capture so context derived during a session has a path into the persistent layer
• Conflict detection so contradictions surface for resolution rather than persisting silently
• Inference from absence so the gaps in the context layer are visible before they cause mistakes

None of these mechanisms require the agents to know about each other directly. The substrate does the coordination. Agents read from it; agents write to it; the substrate ensures coherence across the fleet.

The honest version

Shared memory doesn't eliminate the need for careful agent design. An agent that's poorly prompted or given a bad task definition will still produce bad output — with or without good context. The memory layer closes the context fragmentation problem; it doesn't close the agent design problem.

The compounding value is also time-dependent. A fleet running on a shared substrate for six months has more to work with than one that started yesterday. The substrate gets richer as the fleet runs. Early outputs are better than cold-start; later outputs are better still.

The context fragmentation problem is the second-order failure mode of multi-agent deployment. First-order: getting the agents to run at all. Second-order: getting them to stay coherent with each other over time. The substrate is what closes the second-order gap.