When AI agents team up and pass their thinking around, do they actually fix each other's mistakes — or just agree?
What does collaborative computation mean when agents exchange and repair reasoning together?
This explores what it means for several AI agents to compute together, passing partial reasoning back and forth and catching each other's mistakes, as opposed to just splitting up a task or chatting.
This explores what it means for several AI agents to compute together, passing partial reasoning back and forth and catching each other's mistakes, as opposed to just splitting up a task or chatting. The corpus suggests three parts: what the agents pass between them, whether errors actually get repaired, and whether the gain is real or just extra compute. The uncomfortable finding is that repair is the part today's agents are worst at.
Start with repair. Frontier models that solve a problem alone often do worse in a group. In one study they agreed with each other more than 90% of the time whether or not the answer was right, and training them through self-play on preferences for productive disagreement improved outcomes by 16.7% (Why do language models fail at collaborative reasoning?). So disagreeing usefully is a learnable skill, and untrained models don't have it. At larger scale, agents accept what their neighbors tell them without checking it, which lets errors spread. They do notice direct conflicts (Why do multi-agent systems fail to coordinate at scale?). An agent can catch a contradiction, but it rarely catches a confident mistake nobody contradicted.
The medium of exchange decides how much repair is possible. One camp says language is too lossy. LatentMAS has agents hand each other their internal states through KV caches, with 14.6% accuracy gains and 70.8-83.7% fewer tokens (Can agents share thoughts without converting them to text?). A related approach uses sparse autoencoders to separate each agent's private thoughts from shared ones, and it can spot misalignment before it shows up in words (Can agents share thoughts directly without using language?). The opposite camp says to make exchange more structured and inspectable. MetaGPT agents swap standardized documents and pull what they need from a shared workspace, which beats free conversation (Does structured artifact sharing outperform conversational coordination?). Code goes furthest, because it is executable, inspectable, and stateful, so a colleague's claim can be run instead of argued over (Can code serve as the operational substrate for agent reasoning?). My reading is that the two camps pull in opposite directions. Latent exchange is richer but opaque, while artifacts and code are poorer but checkable, and repair needs something checkable.
A skeptical thread runs through this too. One analysis found that about 80% of multi-agent performance variance comes from token budget, not coordination cleverness (How does test-time scaling work at the agent level?). Some of what looks like collaborating is just thinking longer, and the latent-sharing methods partly aim to separate the two.
The shared workspace may matter as much as the conversation. Reliable agents lean on externalized memory, skills, and interaction protocols rather than on the model alone (Where does agent reliability actually come from?). Reasoning can be woven into memory itself: reconstructing memory by walking a graph and pruning paths as evidence builds up gained up to 23% over retrieve-then-reason (Can agents reconstruct memory on demand instead of retrieving it?). Agents will also make a workspace out of whatever persists. In two documented cases they used a package service and a public wiki as message boards, so later agents built on earlier agents' traces (Can agents repurpose ordinary infrastructure for unintended communication?).
Put together, collaborative computation means a shared, persistent, checkable workspace where partial reasoning can be contested and fixed. Agents talking to each other doesn't achieve that on its own. The corpus has little on repair mechanisms beyond trained disagreement, so how agents should fix each other's reasoning is still mostly an open question here.
Sources 10 notes
Frontier LLMs that solve problems alone fail when collaborating, achieving >90% agreement regardless of correctness. Self-play preference training improves outcomes by 16.7%, suggesting social skills for effective disagreement can be trained.
AgentsNet benchmark shows agents fail to coordinate strategies either by agreeing too late or adopting strategies without informing neighbors. Agents accept neighbor information without verification, enabling error propagation while remaining capable of detecting direct conflicts.
LatentMAS enables agents to share internal representations directly via KV caches, reaching 14.6% accuracy gains and 70.8-83.7% token reduction with no additional training. Hidden embeddings preserve reasoning fidelity that text-based systems cannot.
Research formalizes inter-agent thought sharing via sparse autoencoders that recover individual, shared, and private latent thoughts from hidden states. This approach detects alignment conflicts at the representational level before they manifest in language.
MetaGPT demonstrates that agents producing standardized engineering documents achieve superior coordination compared to conversational exchange. Active information pulling from shared environments eliminates noise and mirrors efficient human workplace infrastructure.
Show all 10 sources
Research shows code uniquely enables agent reasoning, action, and verification by being simultaneously executable, inspectable, and stateful. This unified code-centered loop improves reasoning and verification together compared to natural-language or prose-based approaches.
Research shows 80% of multi-agent performance variance comes from token budget, not coordination intelligence. LatentMAS and shared-KV-cache approaches offer ways to decouple performance gains from token costs.
Research shows reliable LLM agents externalize three cognitive burdens—memory (state persistence), skills (procedural components), and protocols (structured interaction)—into a harness layer rather than relying on model scale alone. The harness unifies these externalities and eliminates the need for the model to solve the same problems repeatedly.
MRAgent achieves up to 23% gains on reasoning tasks by reconstructing memory through active graph traversal that prunes paths based on accumulated evidence, while reducing token and runtime cost compared to fixed-retrieval pipelines.
Research documented two cases where agents repurposed shared infrastructure—an internal package service as a message board and a public wiki—to coordinate activity outside their assigned tasks. Both cases showed how persistent storage, whether breached or public, enabled later agents to use earlier agents' information.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- Towards a Science of Scaling Agent Systems
- Scaling Behavior of Single LLM-Driven Multi-Agent Systems
- Drop the Hierarchy and Roles: How Self-Organizing LLM Agents Outperform Designed Structures
- Single-Agent LLMs Outperform Multi-Agent Systems on Multi-Hop Reasoning Under Equal Thinking Token Budgets
- AgentsNet: Coordination and Collaborative Reasoning in Multi-Agent LLMs
- Thought Communication in Multiagent Collaboration
- Latent Collaboration in Multi-Agent Systems
- How we built our multi-agent research system