When Agents Talk Too Much: The Hidden Crisis of Multi-Agent Communication Efficiency Link to heading

2026-06-07 | Deep Dive | Based on arXiv 2606.05304 + ICLR 2026 SupervisorAgent + Industry Framework Analysis

It’s June 2026. Three years have passed since AutoGPT and BabyAGI ignited the multi-agent craze.

In those three years, multi-agent collaboration has evolved from a “chain two LLM calls with LangChain” experiment into an industrial-grade paradigm where 1,000 agents execute concurrently inside Claude Code. Anthropic’s just-released Dynamic Workflows lets users schedule thousands of intelligent agents in a single task. OpenAI Codex breaks down software development into chains of sub-agents. CrewAI, AutoGen, and LangGraph each boast tens of thousands of GitHub stars—we seem to have accepted as default that “if one agent can’t solve it, throw ten agents at it.”

But on June 6, 2026, an arXiv paper from the Singapore University of Technology and Design (SUTD) raised a question that forces the entire direction to be re-examined:

“What Should Agents Say?"—What exactly should agents say to each other?

This deceptively simple question punctures the deepest hidden cost inside multi-agent systems (MAS). And when we combine it with a related paper from ICLR 2026, a communication-pattern analysis of mainstream frameworks, and new variables introduced by the reasoning-model era, we reach a sobering conclusion: inter-agent “chatter” is shifting from an optimization target to a survival condition.

I. The Physics of the Problem: The O(n²) Communication Disaster Link to heading

Imagine a sequential pipeline with 5 agents, the most typical agent orchestration pattern in 2026:

User request → Agent A analyzes → Agent B codes → Agent C tests → Agent D deploys → Agent E reports

Under “unconstrained natural-language communication,” here’s what each interaction actually looks like:

1. Agent A receives the user request and calls an LLM. Its output includes: requirement understanding, analysis process, initial solution proposal. Roughly 2,000 tokens.
2. Agent B receives as input: user request + Agent A’s full 2,000-token output. It then produces roughly 3,000 tokens (code + explanation).
3. Agent C receives: user request + A’s 2,000 + B’s 3,000. It produces roughly 2,500 tokens (test report).
4. Agent D receives: user request + A(2,000) + B(3,000) + C(2,500). Plus its own 1,500.
5. Agent E receives: user request + A(2,000) + B(3,000) + C(2,500) + D(1,500). Plus its own 1,000.

Cumulative token consumption: each downstream agent processes a linearly growing context, but the API cost per call = input token price × accumulated context size. When a task involves 20 interaction rounds, the 20th round’s input may already span tens of thousands of tokens—and at least 70% of those tokens are redundant.

And this doesn’t even factor in reasoning models. If you swap Agent C for Gemini 3.1 Pro Thinking, its internal chain-of-thought alone could be 8,000 tokens of deliberation—all of which gets shoveled into Agents D and E’s shared history.

This isn’t linear growth. This is compound interest.

II. What the PACT Paper Found: Agents Don’t Need to Write Essays Link to heading

SUTD’s What Should Agents Say? is the first paper to systematically treat “inter-agent communication content” as an independent variable.

2.1 Five Communication Strategies, None Dominant Link to heading

The research team tested the five most common inter-agent communication patterns across two MAS topologies (Split-evidence and Sequential Pipeline):

Core finding: no single fixed strategy is optimal across all scenarios. But one common pattern emerged—in every effective case, what got transmitted was “action-state” information, not “complete natural-language narratives.”

In other words: agents need to fill out forms, not write essays.

2.2 PACT: Turning Agent Communication into State Updates Link to heading

Based on this finding, the research team proposed PACT (Protocolized Action-state Communication and Transmission).

PACT’s core idea is remarkably simple: treat inter-agent communication as a “public state update” problem. When each non-terminal agent completes its task, its output isn’t pushed directly into shared history. Instead, it first passes through a “projection layer”—compressed into a compact action-state record. This record contains only three things:

• What was done (action)
• What state changed (state delta)
• What downstream needs to know (dependency/flag)

Only then is the compressed record written into shared history for downstream agents to consume.

What does this sound like? Git commit messages.

The Git community, through decades of evolution, reached consensus: a commit message should be a one-line subject plus a body that describes “what was done” and “why,” not the entire diff and the developer’s thought process. Nobody wants to read a 3,000-line commit message. Yet multi-agent systems today are doing the equivalent of stuffing every agent’s internal diff, thinking notes, and even failed retry logs into the downstream context.

2.3 Quantified Impact: Not Incremental—Transformational Link to heading

The paper’s measurements on production-grade code-agent frameworks are compelling:

• OpenHands (production dev framework): with PACT, the token-per-resolved metric dropped 10% while the task resolve rate increased. Cheaper and more accurate.
• SWE-agent: while maintaining the same resolve rate, input token consumption was halved.

“Tokens halved, success rate unchanged”—in any engineering metric, that’s a first-priority outcome.

III. SupervisorAgent: A Different Route, Same Destination Link to heading

Another paper accepted at ICLR 2026, Stop Wasting Your Tokens: Towards Efficient Runtime Multi-Agent Systems, attacks the same problem from a different angle.

SupervisorAgent’s approach: insert a lightweight “supervisor agent” at critical interaction nodes. Its job isn’t participating in business logic—it does three things purely:

1. Filter noise: strip out fluff, repetition, and failed-retry logs from upstream agent output
2. Correct errors: intercept erroneous information before it contaminates downstream context
3. Purify observations: compress what’s passed into minimal effective information

Crucially, this supervisor agent is triggered by an LLM-free context filter—meaning it consumes almost zero tokens itself.

On the GAIA benchmark (one of the most challenging evaluations for multi-agent systems), SupervisorAgent reduced Smolagent’s average token consumption by 29.68%, with zero loss in success rate. The same result held across five additional benchmarks—math reasoning, code generation, question answering—and multiple SoTA base models.

If you put PACT and SupervisorAgent side by side, they’re saying the same thing: the default mode of agent communication (free-form natural language + full pass-through) is wrong. The difference: PACT solves it at the protocol layer (defining what agents should transmit), while SupervisorAgent solves it at the runtime layer (filtering what gets transmitted). The two are fundamentally complementary.

IV. How Current Mainstream Frameworks Handle Communication: A Reality Check Link to heading

This calls for a hard look at how today’s most popular agent frameworks actually handle communication.

CrewAI Link to heading

Forces sequential agent execution. What does that mean? The previous agent’s complete output, unchanged, becomes the next agent’s entire input context. This is an O(n²) token-exponential trap. In a 5-agent pipeline, the 5th agent’s input context may be 5× larger than the 1st’s.

AutoGen (Microsoft) Link to heading

Based on a group-chat model, defaulting to full conversation history. As turns accumulate, context per API call undergoes quadratic explosion (every agent’s every historical utterance is visible to all). Microsoft has recognized the problem and introduced max_turns limits and conversation-summarization mechanisms to truncate long tails—but this is essentially “replace raw output with summaries,” similar to the approaches tested in the paper, and its effectiveness depends on summary quality.

LangGraph Link to heading

Based on graphs and state machines. All agents read from and write to a centralized State dictionary, passing structured state rather than free-form text. Among mainstream frameworks, this is the most advanced in communication efficiency—it natively achieves what PACT aims for: replace natural-language chat with structured state. But LangGraph’s limitation is that it requires developers to explicitly define the state schema, adding design overhead and making it less flexible for highly unstructured collaboration scenarios.

Claude Code / Codex (OpenAI) Link to heading

The communication patterns of these two agentic coding tools are somewhat unique. They primarily interact with tools via protocols like MCP (Model Context Protocol), with relatively little internal agent-to-agent communication. More often, they adopt a “monolithic mega-context” strategy—dumping massive amounts of information into a long-context model at once and letting the model figure out understanding and scheduling on its own. This works at present (Gemini 3.1 Pro has a 2-million-token context window), but it’s unsustainable for the same fundamental reason: context windows may be getting larger, but attention density dilutes as the window grows.

V. The Reasoning Model Era: The Thinking-Trace Amplification Disaster Link to heading

If the problems discussed so far were merely “optimization targets,” the arrival of reasoning models turns them into “requirements.”

In 2026, OpenAI GPT-5.5, DeepSeek-V4, Gemini 3.1 Pro Thinking, Claude Opus 4.8, and other reasoning models all default to (or optionally enable) long chain-of-thought reasoning internally. A single inference can generate thousands to tens of thousands of tokens of hidden thought:

"Hmm, let me reconsider this problem. Starting from first principles..."
"Wait, there's a flaw in my earlier reasoning..."
"Actually, there's another possibility..."
"Taking all of the above into account, my conclusion is..."

These thinking traces have real value—they make models reason deeper and more accurately. The problem: if the MAS framework doesn’t isolate these traces, they get shoved wholesale into shared history.

The consequences are catastrophic:

1. Token billing spirals out of control: a 2,000-token final output may sit atop 8,000 tokens of chain-of-thought. Three downstream agents each then replicate this 8,000-token context overhead.
2. Cross-agent contamination: Agent B reads Agent A’s internal deliberation (“Hmm, wait…” “Actually, there’s an issue…”) and may be misled by A’s hesitation, making unnecessary corrective moves.
3. Attention dilution: research shows LLMs already struggle to process information in the middle of their context (“Lost in the Middle”). When the context is stuffed with other agents’ thinking processes, the probability of critical information being buried soars.

This is precisely where PACT and SupervisorAgent deliver their greatest value in the reasoning-model era: they enforce isolation of internal thinking traces, passing only final conclusions or structured action-state records between agents. This isn’t a nice-to-have—it’s a prerequisite for reasoning models to participate in multi-agent collaboration.

VI. The Industry Is “Reinventing TCP”: A Brief History of Agent Communication Protocols Link to heading

Across 2025–2026, the industry has recognized that inter-agent communication needs standardization, not each framework rolling its own. Several major protocols are converging:

But these protocols currently solve “how to find agents” and “how to connect agents”—not one of them addresses “what agents should say, and how much, once they’re connected.”

This is exactly where the PACT paper’s significance lies: it attempts to define the communication content layer, not the transport or discovery layer. The analogy to TCP/IP’s four-layer model is apt:

• A2A/ACP/MCP solve the “transport layer” and “application layer”—how data moves, how agents discover each other
• PACT attempts to solve the “presentation layer”—what the data should look like

Just as HTTP/2’s introduction of header compression wasn’t a nice-to-have but the foundational technology that enabled the web to scale, agent communication content compression won’t be an optional optimization—it’s the prerequisite for growing from 5 agents to 500.

VII. Three Actionable Recommendations Link to heading

If you’re building or operating a multi-agent system, these three checks are immediately actionable:

1. Audit Your Agent Communication Logs Link to heading

Grab the full conversation history of any multi-agent task and count: how much content is redundant? How many tokens are utterly useless to downstream agents? How many “Thanks for your analysis” and “Got it, let me handle this” social niceties are burning tokens?

2. Isolate Thinking Traces Link to heading

If your agents use reasoning models, ensure chain-of-thought is stripped before passing to downstream agents. Don’t feed “Hmm, let me think…” to the next agent—it doesn’t need to know how you agonized.

3. Replace Natural-Language Chat with Structured State Link to heading

If you’re using LangGraph, you’re already doing this—but ensure the state schema design converges (only contains what downstream needs) rather than expands (throwing everything in). If you’re using CrewAI or AutoGen, consider inserting a SupervisorAgent-like filtering layer between agents.

Coda Link to heading

The question in 2023 was: “How do we get multiple agents to work together?”

In 2024: “How do we get multiple agents to work together efficiently?”

In 2025: “How do we get 1,000 agents to work together efficiently?”

In 2026, the PACT and SupervisorAgent papers tell us: the answer lies not in better orchestration—but in less noise.

Agent communication protocols may be the next infrastructure-level opportunity. Just as TCP/IP defined how nodes on the internet handshake, the “presentation layer” of the Agent Communication Protocol will define how AI agents collaborate efficiently at scale. And the PACT paper may be one of the earliest milestones on that path.

References:

• Chen Huang et al., What Should Agents Say? Action-state Communication for Efficient Multi-Agent Systems, arXiv: 2606.05304, 2026-06-06. SUTD.

• Stop Wasting Your Tokens: Towards Efficient Runtime Multi-Agent Systems, ICLR 2026. SupervisorAgent.

• A Survey of Agent Interoperability Protocols: MCP, ACP, A2A, and ANP, arXiv: 2505.02279, 2025.

• Anthropic, Claude Code Dynamic Workflows, 2026.

• OpenAI, Codex Agent Architecture, 2026.

• PACT open-source implementation: https://github.com/iNLP-Lab/PACT