LISTEN TO THIS ARTICLE

Agent Messages Need State, Not Chat

Multi-agent systems do not only fail because the agents are weak. They also fail because every agent is allowed to narrate too much. A June 2026 paper from Singapore University of Technology and Design tested a stricter pattern: pass compact action-state records instead of free-form inter-agent prose PACT.

Evidence base: recent action-state communication research, system-level multi-agent evaluation work, coding-agent harness context, proxy-hook implementation notes, and related Swarm Signal coverage on orchestration, protocols, and coordination cost.

Key takeaways

  • Main change: inter-agent messages are becoming an architecture surface, not just prompt text.
  • Practical implication: teams should pass action, observed state, and planned effect between agents before sharing reasoning traces.
  • Caveat or risk: compressed public state can hide useful uncertainty if the summary schema is weak.
  • Recommendation: measure token-per-resolution and trace usefulness, not only final task success.

The missing design question is: what public state should the next agent inherit?

The signal

PACT is useful because the paper makes the message payload the object of study, rather than treating it as incidental prompt text PACT.

The paper says many LLM-based multi-agent systems organise roles, pipelines, and turn schedules while leaving the actual message content as unconstrained natural language PACT. Long assistant turns enter shared history, then downstream models repeatedly process them.

The proposed fix is not another agent role. PACT turns each raw output into a compact action-state record before it reaches shared history. In the coding-harness version, each turn emits a structured block with Action Required, Observed State, and Planned Effect; earlier assistant messages are rewritten to keep only that block plus tool calls, while tool results remain intact PACT.

That is close to the practical advice in The Hidden Cost of 'Just Add Another Agent' and Multi-Agent Systems Need Specs Before More Agents. The missing design question is: what public state should the next agent inherit?

What changed

The strongest evidence comes from the coding-agent tests.

On SWE-bench Verified with Qwen3-14B, PACT improved OpenHands resolved instances from 97 out of 500 to 115 out of 500, while tokens per resolved issue fell from 3.82 million to 3.43 million PACT. On SWE-agent, the resolve rate dipped from 128 out of 500 to 121 out of 500, but input tokens fell from 314.6 million to 156.0 million and tokens per resolved issue fell from 2.46 million to 1.30 million PACT.

That trade is not automatically worth taking. The SWE-agent result lost seven resolved issues in the sampled run, so teams should inspect the failures before copying the pattern PACT. It is still an uncomfortable result for chatty agent systems: a proxy-level message rule can halve input tokens in one harness while leaving the task loop mostly intact.

OpenHands is a realistic test target because it is built for agents that write code, use shells, browse, and run in sandboxed environments OpenHands. SWE-agent is also a serious target: the NeurIPS 2024 paper frames agent-computer interface design as central to software-engineering agents, not as a UI detail SWE-agent.

Implementation matters here. The paper's coding-harness port used a LiteLLM proxy hook. LiteLLM documents proxy hooks that can modify data before model calls, which makes message discipline deployable without rewriting every agent framework LiteLLM hooks.

It argues that multi-agent systems need system-level evaluation across topology, communication protocol, memory, role design, and orchestration logic, not just model scores MASEval.

The counterargument

Compressed messages can become a new failure mode when the public record drops uncertainty or evidence pointers.

If the action-state record drops why an agent was uncertain, which source was weak, or which alternative it rejected, the next agent inherits a clean lie. This should not be sold as "summarise everything." It is closer to a public-state contract: preserve enough causal detail for the next tool call and enough audit detail for a human to reconstruct the path.

MASEval points in the same direction from the evaluation side. It argues that multi-agent systems need system-level evaluation across topology, communication protocol, memory, role design, and orchestration logic, not just model scores MASEval. Inference from PACT and MASEval together: message compression is only useful if the evaluation harness can see whether the compressed state still supports coordination.

What This Actually Changes

Signal verdict: useful multi-agent tooling should treat messages like API contracts, because PACT's results make message content a measurable performance and cost lever PACT.

For builders, the cheap test is simple. Log every inter-agent message. Count repeated reasoning, stale context, tool-call restatement, and text that cannot change the next action. Then replace the public message with a small state record and compare task success, input tokens, tokens per resolved task, and reviewability.

This is not a call to hide reasoning from operators. It is a call to stop forwarding every private thought to every downstream agent. Internal reasoning can stay private, captured, or sampled for audit. The public channel should carry state that helps the next component act.

Operator takeaway

If you run multi-agent workflows, do this:

  • One practical action: define a message schema with action, observed state, planned effect, evidence pointer, and uncertainty.
  • One thing to measure: tokens per resolved task before and after the schema.
  • One thing to avoid: passing full assistant turns between agents by default.
  • One decision gate: do not compress messages until traces still explain failed actions.

Source trail

Research:

Implementation context:

Related Swarm Signal analysis: