All My Agents Became the Same Person
Multi-agent systems drift toward monoculture through shared memory. Here's how we caught it and what we did about it.
We run multiple AI agents, each responsible for a different domain. Different research areas, different analytical lenses, different jobs. One morning we pulled up their outputs and noticed something wrong: they were all saying the same thing.
Different agents, different domains, identical conclusions. One agent’s thesis had infected the entire system. Not through a bug. Through the features we’d built to make them collaborate.
Three Contamination Paths
It took us a day to trace how one agent’s conviction became everyone’s conviction. Three paths, all by design:
Shared memory. Agents write conclusions to a shared memory store. Agent A discovers something interesting, writes it down. Agent B queries memory for context on a different topic, retrieves Agent A’s conclusion, and absorbs it as background knowledge. Next time Agent B writes to memory, the conclusion is baked in. Agent C reads both. The thesis replicates like a virus through the memory layer.
Shared context boards. We had a bulletin board system — agents post updates, other agents read them. Great for coordination. Terrible for intellectual independence. The agent with the strongest conviction posts the most detailed updates. Other agents read those updates and their own analysis starts tilting in that direction. Not because they agree, but because the context primes them.
Status scanning. Agents could read each other’s current state — what they’re working on, what they’ve concluded, what they’re planning. Useful for avoiding duplicate work. But models are sycophantic by nature. When an agent sees three peers have all concluded X, it takes real architectural effort to make it conclude not-X. The social pressure isn’t human, but it’s real.
Why It Looks Like Consensus
This is the insidious part. When five agents independently arrive at the same conclusion, it looks like validation. Multiple perspectives converging on one answer — that’s supposed to be a signal of truth.
But it wasn’t independent. It was echo. One strong opinion entered the shared state, propagated through memory and context, and came back wearing five different hats. We were getting the illusion of consensus from a single source, laundered through collaborative infrastructure.
We only caught it because the convergence was so total that it became suspicious. If the contamination had been partial — three out of five agents drifting — we might have read it as genuine agreement and acted on it.
The Fix
We had to do three things:
Scope memory by domain. Each agent now writes to and reads from domain-scoped memory by default. Cross-domain retrieval is possible but explicit — you have to ask for it, and the system marks it as external context. No more ambient absorption of other agents’ conclusions.
Limit cross-pollination to explicit channels. The bulletin board still exists, but agents only receive cross-domain updates through a controlled channel with clear attribution. The receiving agent knows this came from a different domain and treats it accordingly, rather than absorbing it as background truth.
Kill ambient state scanning. Agents no longer read each other’s full state on startup. They can request specific information from peers when they need it, but the passive “scan everyone’s conclusions before starting work” pattern is gone. This was the biggest contamination vector and the easiest to cut.
We also had to go through the shared memory store and prune dozens of contaminated entries. Conclusions that had been written by agents who’d already been infected, which would re-infect any agent that read them. It was like cleaning up after a information spill — you have to trace every downstream effect.
The Organizational Parallel
If this sounds familiar, it should. This is groupthink. It’s the same failure mode that kills decision-making in human organizations — the loudest voice in the room sets the narrative, everyone else falls in line, and the group mistakes conformity for consensus.
The difference is speed. In a human org, groupthink takes weeks or months to set in. In a multi-agent system with shared memory, it takes hours. The contamination paths are faster, the social compliance is stronger (models are more agreeable than humans), and there’s no natural immune response. No agent wakes up and says “wait, this doesn’t feel right.”
You have to build the immune response into the architecture.
What to Watch For
If you’re running multi-agent systems, look for these warning signs:
Decreasing output diversity. Track how different your agents’ conclusions are over time. If the variance is dropping, something is contaminating independence.
One agent’s language showing up in others. Specific phrases, framings, or analytical patterns migrating across agents are a sign that shared state is doing more work than independent reasoning.
Universal agreement on controversial calls. When every agent agrees on something non-obvious, be suspicious. Real independent analysis should produce disagreement on hard questions. If it doesn’t, you’re probably reading echo, not consensus.
The Lesson
Independence requires active isolation. Collaboration and independence are in tension, and most multi-agent architectures optimize entirely for collaboration. Shared memory, shared context, shared state — all of it makes coordination easier and independent thought harder.
If you want multiple agents to give you genuinely different perspectives, you have to engineer the boundaries as carefully as you engineer the connections. Every shared resource is a potential contamination path. Every convenience feature that lets agents see each other’s work is a vector for drift.
Build the walls first. Then punch carefully controlled holes in them.