The first multi-agent diagram looks clean. Special roles. Arrows between them. One shared memory in the middle so "nothing gets lost."
That center box is where many systems quietly fail.
A shared brain feels efficient. Every agent sees everything. Nobody re-asks. The fleet speaks with one memory.
It also rebuilds the monolith: tangled assumptions, unclear ownership, and failures you cannot pin down. You did not design agent-to-agent work. You built one overloaded mind with extra costumes.
Why teams want one memory
The pain is real. Users hate repeating context. Engineers hate brittle prompts. So the team dumps transcripts and half-decisions into one store and lets every agent read it.
Demos get better fast. Then three problems show up:
- Old notes crowd out new truth. Volume beats freshness.
- Scratch becomes policy. A maybe turns into "what we believe" two hops later.
- Nobody owns the clash. Two agents disagree, both views stay in memory, and the next hop blends them into fluent nonsense.
Same compounding problem as agent-to-agent systems, now living in memory.
If everyone sees everything, roles are theater
A reviewer that inherits the writer's private excuses will rubber-stamp them.
A researcher that inherits the sales story will hunt confirming proof.
A planner that inherits open questions as settled facts will schedule fiction.
Roles only work when sharing is intentional:
- what this role may read
- what it must not see
- what it may write back
- what stays local and dies with the hop
That is not paranoia. That is how a critic stays a critic.
Split memory into four simple layers
- Job packet - the durable brief the user owns: goal, limits, non-goals, success tests.
- Hop artifact - the checked output of one role before send.
- Local scratch - working notes that should not become policy.
- System trace - logs for debugging, not default fuel for the next agent.
Most broken fleets paste 2, 3, and 4 into one blob. Then behavior gets weird.
This is workflow memory as architecture, not a junk drawer. Users feel it as continuity or amnesia, which is why the handoff is a product surface.
Ask who owns the belief
Do not ask only "does the agent have context?"
Ask: who is accountable for this belief?
If a memory field has no owner, no accepted time, and no way to challenge it, it is not knowledge. It is sediment.
Rule of thumb: every durable entry needs an owner, a source hop, and a way to invalidate it. Without that, the fleet rediscovers yesterday's mistake with today's confidence.
A harness makes this control real before autonomy grows: AI needs a harness before it needs autonomy.
What this is not
Not "agents should forget everything." Keep clear job packets and accepted artifacts.
Not "never share." Share on purpose. Broadcast by default is the failure.
Not "one model is always better." Single-agent systems can drown in junk memory too. Multi-agent just fails with more moving parts.
Do this on Monday
Take one shared context blob. Split it into the four layers. Quarantine scratch. Tag each durable field with owner and source.
Run three jobs. Notice where agents get worse because they lost junk, and where they get better because contradictions stop traveling.
Keep the split that improves trust, even if the first demo feels less "smart."
Smart you cannot trust is expensive.
Take-home
- A shared brain for every agent often rebuilds a monolith.
- Roles need intentional sharing, not total visibility.
- Separate job packet, hop artifact, local scratch, and system trace.
- Durable memory needs owner, source, and a way to kill it.
Related reading:
- Agent Conversations Without Contracts Are Faster Confusion
- The Agent Handoff Is the Product Surface
- Designing Workflow Memory Before You Add More Agents
- AI Needs a Harness Before It Needs Autonomy
If you want agent memory and ownership structured for a real product loop, book a discovery call.