PACT: Structuring Agent-to-Agent Communication

In multi-agent systems built on LLMs, the design of roles and pipelines usually gets all the attention. What agents say to each other, meanwhile, is almost always left to unrestricted natural language. A paper published on arXiv on June 6, 2026 quantifies the cost of that choice: free-form communication drives up token consumption, fills the shared context window, and ends up degrading both system performance and the inference bill.

The authors analyze five common communication strategies between agents across two distinct multi-agent system (MAS) topologies and reach an uncomfortable conclusion: no single fixed strategy is universally optimal. What does appear consistently in messages that work well is that they preserve action-focused information that downstream agents need to operate. From there, they build PACT.

What is PACT and how it works

PACT stands for Protocolized Action-state Communication and Transmission. The core idea is to treat communication between agents not as an exchange of free natural language, but as a problem of public state updates. Each raw output from an agent is projected into a compact action-state record before entering the shared history.

In other words: instead of agent A writing a paragraph explaining what it did and why, the system extracts a structured record with exactly the information agent B needs to continue. Everything else is discarded. The history grows more slowly, the context window frees up, and downstream agents don't have to process noise.

The paper reports that PACT consistently improves the performance-cost ratio across different MAS topologies: performance comparable to or better than unprotocol strategies, with substantially fewer tokens. The authors extend validation to real-world coding environments, moving the result away from lab benchmarks toward actual conditions.

Why it matters now

As of June 2026, MAS is already a common way to deploy complex tasks with Claude and other LLMs. Platforms like Claude Code allow you to chain specialized sub-agents that delegate work to each other; MCP servers add external tools that agents invoke in sequence. In that context, the volume of inter-agent messages scales quickly, and so does the cost.

The problem that PACT describes is not theoretical. Any team that has operated a pipeline of more than three agents with long conversations knows the symptom: the context fills up, the agent starts losing track of earlier steps, and you have to truncate or reset. Common solutions—summarizing with an extra agent, manually compressing prompts, increasing the context window—have their own costs. PACT bets on attacking the problem at the source: getting agents to generate smaller, more useful messages from the start.

For whom it's relevant

The paper is required reading for anyone designing multi-agent architectures in production. This includes those working with Claude Code building sub-agent flows, teams developing MCP servers with multiple chained tools, and any organization seeing their inference costs grow as their pipelines gain complexity.

For those researching communication in MAS, the added value is the comparative analysis of the five previous strategies and the formalization of the problem as public state updates, a framing that makes it easier to reason about what information should or shouldn't cross the boundary between agents.

What PACT doesn't solve, and the paper doesn't claim to, is the design of roles or the orchestration logic. It's a specific piece of a larger puzzle.

---

From our perspective, PACT is a solid, well-scoped contribution: it doesn't reformulate MAS, but rather plugs a concrete gap that production teams already know about. The fact that results validate in real-world coding environments adds credibility; we'll need to see whether it holds up in domains with less structured messages than code.