1 Introduction↩︎

Large language models (LLMs) are increasingly deployed as multi-agent systems (MAS) [1], [2]. In these systems, several agents collaborate to solve complex tasks that a single model call handles poorly [3]–[5]. Such collaboration can take many forms, including debate [6], [7], sequential pipelines [8]–[10], retrieval-based relays [11], and tool-using agents [12]. The paradigm is already widely deployed in agentic coding assistants [13], [14] and open agent platforms [15], [16], decomposing a task across many cooperating model calls and outperform single-shot prompting. This effectiveness carries a cost: a MAS issues many model calls whose outputs feed one another, so it consumes far more tokens, often many times more, than a single model solving the same task [17], [18].

This issue becomes especially severe when modern reasoning models are used in multi-turn settings [19]–[21]: once an agent forwards a long internal reasoning trace, every downstream agent must repeatedly process it as part of the shared dialogue history [22]. As shown in Figure 1, verbose or noisy messages are repeatedly reprocessed by downstream agents, causing token costs to compound across turns and potentially exhausting the context window before the task is completed, which can ultimately degrade performance [7], [11]. However, existing MAS research has largely focused on roles, turn-taking schedules, and tool allocation [3], [4], [23], [24], while leaving the inter-agent message itself as mostly unconstrained free-form natural language. We argue that the inter-agent message is a central design lever: the content of messages between agents directly shapes both MAS performance and token cost.

Specifically, we ask: what should an agent send to another agent in a MAS? We conduct a diagnostic analysis of inter-agent communication across two different MAS settings: a split-evidence interaction and a sequential pipeline. The analysis compares five common strategies: forwarding the agent’s full free-form output, using native concise generation, keeping only the final conclusion, producing a short summary of the turn, and passing only the role artifact (§3). The analysis shows that no single strategy is uniformly best across topologies: forwarding the full output is expensive and redundant, generic shortening can remove task-relevant information, conclusion-only messages are too lossy when the receiver lacks surrounding state, and artifact-only messages capture useful task content but still leave the receiver to infer the sender’s intended action and grounding evidence. We therefore view inter-agent communication as a public state-update problem: the message should not summarize the sender’s private reasoning, but should update the shared state with the minimal action-relevant information needed by later agents.

Motivated by this observation, we introduce PACT (Protocolized Action-state Communication and Transmission), a minimal and harness-agnostic communication protocol that projects each non-terminal agent’s raw output into a compact public action-state message before it is appended to the shared history. Rather than exposing the sender’s full generation transcript, PACT retains only the receiver-facing information needed for continuation: the action taken or required next, the task-relevant state, and the resulting artifact to be used downstream. Across model scales and MAS settings, PACT consistently reduces token usage while preserving and often improving task performance. We further port PACT to two real-world agentic coding harnesses, OpenHands [15] and SWE-agent [16]. The same communication rule yields substantial reductions in token usage with minimal performance degradation, indicating PACT is also practical as an inference-time communication protocol for existing agentic applications.

Our contributions are summarized as follows:

• Through a systematic analysis of communication strategies in inter-agent message in MAS, we show that no fixed policy is universally optimal, indicating that what agents pass to one another is a central but underexplored design dimension.

• We introduce PACT, a training-free and harness-agnostic communication protocol for MAS, defining the boundary between private computation and public communication.

• Experiments on two MAS settings show that PACT substantially improves the performance–cost frontier, reducing token usage by 38.7% on average across baselines and model scales while preserving or improving task performance. On real-world coding harnesses, PACT reduces tokens-per-resolved by 47% on SWE-agent, demonstrating its practical significance.

2 Related Work↩︎

2.0.0.1 Multi-agent systems.

LLM-based multi-agent systems (MAS) coordinate several model instances to solve tasks beyond a single call. Research has largely explored who talks and when: role specialisation and persona self-collaboration [5], [25], peer debate and critique [6], [26], general multi-agent conversation frameworks [3], [4], and parallel output aggregation [23]. These designs differ in roles or orchestration, but uniformly leave the content of each inter-agent message to free-form natural language. We examine through systematic experiments and show that the content one agent pass to the next matters in both performance and cost.

2.0.0.2 Token consumption in MAS.

The token cost of multi-agent coordination arises from repeated context reuse: one agent’s output becomes part of another agent’s input, and later agents must reprocess earlier messages. This effect is especially pronounced when agents forward deliberative content, such as chain-of-thought reasoning [27], because the same reasoning traces are repeatedly read by downstream agents [28]. Prior work studies the shape of inter-agent messages and shows that disciplined communication affects accuracy and cost [10], [11], [18]. While studies pay attention to who should the agent talk to under various topologies [29], [30], what content should be communicated is largely ignored. Instead, PACT defines a communication invariant over shared history: only action, grounded state, and reusable result are made public, while private deliberation remains outside the inter-agent channel.

2.0.0.3 Agentic harnesses for real-world tasks.

Beyond research scaffolds, agentic harnesses are increasingly built to solve real-world problems, most prominently software engineering [1], [24], [31]: SWE-bench [32] evaluates agents on real GitHub issues, and OpenHands [15] and SWE-agent [16] are widely used loops that interleave reasoning, tool calls, and environment feedback over long trajectories. Because such harnesses accumulate long tool-augmented histories, the per-turn message and shared-history budget can easily scale up. We show that passing the action-state related information only is enough to reach comparable results while significantly reducing the token usage.

3 Diagnostic Analysis of Inter-Agent Communication↩︎

Following the question raised in §1, we examine how an agent’s output should be handled in the inter-agent message, isolating this single choice while holding all other MAS design factors fixed. We analyze five communication strategies that cover today’s common choices, in two structurally different MAS settings, at various model scales.

3.1 Two MAS Settings↩︎

3.1.0.1 Setting A — Split-Evidence Interaction.

We use a symmetric two-agent setting where the evidence needed to solve the task is split across agents. Each agent receives only partial information, so neither agent can reliably answer the question alone. The agents must exchange task-relevant evidence over multiple turns and combine their partial views to produce the final answer.

3.1.0.2 Setting B — Sequential pipeline.

In this setting, the task is processed sequentially among the agents, each agent will take the output of previous agents as input and solve the task building on earlier intermediate artifacts. We adopt a widely studied role-specialised pipeline [10], [18] of four agents run in fixed order—Planner, Critic, Refiner, and Solver. The Planner produces a plan, the Critic reviews it and emits a critique, the Refiner returns a revised plan, and the Solver produces the benchmark answer.

3.1.0.3 Models and settings.

All experiments run on Qwen3-8B, Qwen3-14B, and Qwen3-32B [33]. For the split-evidence interaction setting, we evaluate on HotpotQA [34] and 2WikiMultiHopQA [35]. Each answer depends on combining multiple supporting paragraphs and requires evidence exchange. Each question is supportted by ten paragraphs, including two gold supporting paragraphs and eight distractors, and evenly split them between two agents. For the sequential pipeline setting, we evaluate on three categories of benchmarks: (i) mathematical reasoning, including AIME2024 [36] and AIME2025 [37]; (ii) scientific reasoning, using GPQA-Diamond [38]; and (iii) commonsense question answering, using OpenBookQA [39]. Other experiment details are deferred to Appendix 8.

3.2 Inter-Agent Communication Strategies↩︎

We analyze five strategies that cover the common ways a MAS can pass an agent’s reasoning and output on the inter-agent channel. Full Content appends the agent’s freely generated output, including its internal reasoning trace, to the shared history. Concise Generation lets the model operate in its native non-thinking mode, which usually produces shorter responses. Conclusion Only passes the conclusion / final answer portion to the next agent. Brief Summary explicitly asks the agent to pass a short free-form summary to the next agent. Artifact Only reduces the message to the role artifact alone (e.g., the plan or critique), without the surrounding action description or supporting state.

3.3 From Action-Centered Messages to Structured Handoffs↩︎

Figure 2 shows that no common communication strategy is uniformly satisfactory across the two MAS settings. The useful signal in the inter-agent communication is usually action-centered, but it must also expose the state that makes the handoff reliable. These findings motivate a protocolized handoff that aligns the content of inter-agent messages and makes them compact and stable.

3.3.0.1 Passing the full content is redundant.

Full Content forwards the entire free-form output, including the explanations, which is consistently expensive and rarely gives the best performance. In the sequential pipeline it has the largest token cost at every model scale, while being clearly behind the best-performing alternatives. In the interaction setting it is also not the strongest choice. These results show that forwarding the full transcript is an inefficient default: much of what is passed is not the information the receiver needs to act on.

3.3.0.2 Being short is not enough.

Concise Generation reduces token usage by suppressing long reasoning traces, and it performs well in the interaction setting, where the receiver often only needs a surfaced fact. However, the same strategy is weak in the role-specialized pipeline, where intermediate agents must produce useful plans, critiques, and refinements before the final solver acts. Brief Summary gives a different kind of short message, but its behavior is unstable: it is strong for some 8B interaction and pipeline runs, yet falls behind simpler strategies at larger scales. These results suggest that generic conciseness is not a reliable communication rule: a message can be short while still omitting the information needed by the next agent.

3.3.0.3 Conclusion-only messages are topology-dependent.

Keeping the visible final output while removing the intermediate traces works relatively well in the sequential pipeline, where the fixed role order already tells each agent how to interpret the previous output. In the interaction setting, however, Conclusion Only is much weaker, because the partner needs not only a local conclusion but also the evidence observed by the sender and the missing information still needed for the answer. Thus, removing thinking processes is helpful, but keeping only the conclusion is not a general solution: it depends on whether the surrounding MAS topology already supplies the missing action and state information.

3.3.0.4 Artifact-only messages identify the right content but not the right protocol.

Artifact Only provides the clearest signal about what should be communicated. It often achieves the best in the interaction setting and is competitive in the sequential pipeline, showing that the receiver benefits most from the sender’s action-related work product rather than from the full generation trace. However, Artifact Only is not yet a communication protocol. In the interaction setting it can achieve high accuracy only with very large messages. As shown in Figure 3, Artifact Only runs more turns than other strategies, indicating that suppressing all preamble also suppresses the closure cues agents use to stop. In the pipeline, it is efficient and competitive at larger scales, but weaker for the smaller model, suggesting that an artifact alone may omit useful state or handoff information when the sender is less capable. The artifact is therefore the right starting point, but it must be made structured and compact.

4 PACT: Protocolized Action-state Communication and Transmission↩︎

The analysis result in §3 suggests that the central challenge in inter-agent communication is not merely message length, but the type of information that is preserved for downstream agents. Rather than exposing the sender’s full generation transcript, an inter-agent message should communicate the sender’s action-state: the action taken, the task-relevant state or evidence supporting it, and the result that the next agent needs in order to continue. Building on this observation, we propose Protocolized Action-state Communication and Transmission (PACT), shown in Figure 4, a communication protocol that restricts shared inter-agent history to compact action-state messages while excluding intermediate process-level content.

4.1 General setup↩︎

Consider a multi-agent system with a shared history \(H_t\) at turn \(t\). An agent with role or action \(r_t\) receives its local observation \(o_t\) and the shared history \(H_t\), then produces a raw output \(y_t\). In a standard MAS, this raw output is directly appended to the shared history: \[H_{t+1}^{\mathrm{std}} = H_t^{\mathrm{std}} \oplus y_t ,\] where \(\oplus\) denotes appending a message. This update rule is simple, but it makes every part of \(y_t\) public, including reasoning traces, thought explanations, repeated statements, and the final artifact. These elements are all retained and re-read by later agents.

The idea of PACT is simple: before an agent output becomes shared history, we project it into a compact public message space. Formally, PACT replaces the raw message \(y_t\) and updates the history as \[H_{t+1}^{\mathrm{PACT}} = H_t^{\mathrm{PACT}} \oplus \Pi_{\mathrm{PACT}}(y_t, o_t, r_t) .\] Here \(\Pi_{\mathrm{PACT}}\) is a sender-side projection that determines what information is allowed to enter the inter-agent channel.

4.2 Action-state message space↩︎

PACT represents each public inter-agent message as an action-state record with three receiver-facing fields: Action, State, and Result. Action states what the sender has done, or what the next agent should do; this makes the handoff explicit rather than leaving the receiver to infer the sender’s intent. State records the evidence, observation, environment feedback, or tool result that grounds the message; this allows the receiver to consume the message as a grounded public state rather than an unsupported conclusion. Result contains the action output itself, such as a retrieved fact, a refined solution, or a tool-call result. Together, these fields define the information that is allowed to enter the shared inter-agent channel.

This message space also specifies the boundary of PACT. Each agent may still reason, self-check, or explore alternatives as needed to produce its output. The constraint applies only to what becomes part of the public inter-agent message space. Under PACT, a message retains only the information that is relevant to the action-state record: what action was taken, what state or evidence grounds it, and what result should be passed downstream. Intermediate process content such as hidden reasoning traces or redundant restatements is excluded before the message is appended to the shared history. In this way, PACT separates private computation from public communication , preventing intermediate deliberation from compounding across later context windows.

4.3 Protocol properties↩︎

Since PACT is intended to be a protocol over the inter-agent channel, rather than a template tied to a particular MAS scaffold, it has the following properties. First, PACT does not constrain the agent’s private computation. The agent can still perform internal reasoning and planning in its original manner; PACT only controls which part of the generated output is retained as public communication. This differs from methods that suppress reasoning or alter the agent’s internal solving process and preserves the capability of the agent. Second, PACT is orthogonal to standard MAS design choices. It does not introduce new agents, change the turn schedule, train a compressor, or assume a particular role structure. The same action-state interface can be serialized differently across settings: a split-evidence interaction may write the action, state, and result explicitly, while a role-specialized pipeline may encode part of the action through the role schedule and retain a more compact role artifact. This protocol works for controlled MAS scaffolds and complex tool-using harnesses like agentic coding systems.

5 Experiments↩︎

5.1 Experiment setup↩︎

We evaluate on the same two MAS settings introduced in §3: the two-agent split-evidence interaction (Setting A) and the sequential pipeline (Setting B), over the same six benchmarks. All experiments use Qwen3-8B, Qwen3-14B, and Qwen3-32B [33]. We compare PACT against three representative MAS communication paradigms. Chain of Agents (CoA) [8] chains worker agents in sequence, with each agent reading only the most recent peer message rather than the full inter-agent history. Text-based MAS (TextMAS) [10] uses role-specialised agents that collaborate through unconstrained natural-language messages and retain the full message history in the shared channel. Multi-Agent Debate [6] runs multiple agents that propose initial answers and then debate over several rounds, converging on a final answer by majority vote. We report token-overlap F1 for the interaction setting and exact-match accuracy for the pipeline, alongside the average total tokens per problem. Implementation details for each baseline are given in Appendix 8.

5.2 Main Results↩︎

Tables 1 and 2 show that PACT shifts the performance–cost frontier across both evaluated MAS settings, demonstrating the effectiveness of passing the action-state information.

5.2.0.1 Grounded handoffs outperform full-history communication.

In the split-evidence interaction setting, a successful message must do more than state a local conclusion: it must surface the relevant evidence and clarify what information is still needed from the other agent. This requirement exposes the weakness of unconstrained communication. For example, TextMAS retains the full conversation history, but its free-form generations introduce redundant reasoning and force later turns to re-read unnecessary content. As shown in Table 1, it consumes more tokens than PACT but still performs worse on both benchmarks, indicating that preserving more text does not necessarily provide a more useful handoff. In contrast, as shown in the example in Figure 5, PACT fits the interaction structure by using an explicit action-state format, turning each turn into a grounded handoff rather than a free-form explanation or an unsupported answer fragment. This allows PACT to achieve the best performance while using fewer tokens.

5.2.0.2 Compact artifacts outperform extended deliberation.

In the sequential pipeline setting, the communication requirement is different: each downstream agent needs the artifact-related information to update its own planning. This exposes a different limitation of unrestricted multi-agent interaction. Although Multi-Agent Debate can improve reasoning through repeated answer-level deliberation, its communication is not organized around the intermediate artifacts needed, causing substantial token overhead. As shown in Table 2, PACT achieves comparable or better performance on most benchmarks while using only 19%–23% of the tokens required by Multi-Agent Debate. This suggests that the pipeline benefits less from extended deliberation than from passing compact action-related artifacts that downstream agents can directly use.

5.2.0.3 Stronger models make better use of compact communication.

The scale trend further supports the role of sparse public communication. Under PACT, stronger models require less explicit inter-agent communication while achieving better task performance. In the sequential pipeline, PACT’s average token usage decreases by 21.1% from Qwen3-8B to Qwen3-32B, while increasing the mean accuracy by 4.2 points. A similar reduction appears in the interaction setting, where PACT’s token usage decreases as the model scale increases on both benchmarks. This suggests that stronger agents can better exploit compact evidence and refined artifacts, without requiring the sender’s full reasoning process to be repeatedly exposed in the shared history. However, under baseline settings, larger models continue to spend tokens producing and consuming redundant public content. Thus, pure model scaling cannot fix communication inefficiency: lacking a protocol, powerful models still waste tokens on redundant public messages, while PACT enables more private computation and keeps agent communication concise.

5.3 Ablation Study↩︎

Table 3 shows how each field in PACT contributes to effective communication. Removing Action reduces F1 from 69.9 to 64.9, showing that the receiver needs an explicit signal about what information is being provided or requested. Removing State also hurts performance, which indicates that the action result is less useful when it is not grounded in the sender’s observed evidence. The largest degradation appears when both action and state are removed and only Result is forwarded: F1 falls to 64.3 and token usage increases by 12.9%. This suggests that an unsupported result creates ambiguity for the receiver, leading to both worse task performance and less efficient interaction. Overall, the ablation confirms that PACT’s advantage comes from the complete action-state handoff: the action clarifies how the message should be used, the state grounds the message in evidence, and the result carries the factual contribution.

6 PACT on Agentic Coding Harnesses↩︎

The settings so far use predefined MAS scaffolds. We now test whether the communication-content rule transfers to external production agentic coding harnesses it was not designed for, such as OpenHands (CodeActAgent) [15] and SWE-agent [16], on SWE-bench Verified [32], which solves real-world GitHub issues in real environments.

6.1 Porting PACT as a proxy hook↩︎

PACT is implemented as a proxy hook that updates the public messages passed between agent turns in-flight. The hook has two components. First, each turn must emit, before its tool call, a structured <summary> block containing Action Required, Observed State, and Planned Effect—the §4 schema rephrased with forward-looking coding semantics. Second, before each turn the proxy rewrites prior assistant messages to keep only the <summary> block and the tool calls, removing the intermediate process and any free-form prose; tool results are left intact, so the inter-turn channel reduces to the information of action-state summary, tool calling and tool results.

6.2 Results on coding harnesses↩︎

As shown in Table 5, PACT shifts the efficiency frontier in both coding harnesses. On OpenHands, PACT improves both effectiveness and efficiency: the SWE-bench Verified resolve rate increases from \(19.40\%\) to \(23.00\%\) (\(+18\) resolved instances), while tokens-per-resolved decreases by \(10.3\%\) and average completion tokens per call decrease by \(5.3\%\). On SWE-agent, PACT produces an even larger efficiency gain, reducing input tokens from \(314.6\,\text{M}\) to \(156.0\,\text{M}\) (\(-50.4\%\)), which is the dominant cost in this long-context loop with only a small resolve-rate change, while tokens-per-resolved drops by approximately \(47\%\). Thus, the efficiency gain is consistent across both production coding harnesses.

This indicates that PACT is not tied to the controlled MAS scaffolds used in earlier sections. The same action-state principle can be implemented as a lightweight proxy-level intervention and still improves the efficiency of external coding agents. It improves OpenHands, where verbose assistant turns are repeatedly carried through the interaction history, and remains approximately neutral on SWE-agent, where the main gain comes from reducing accumulated input context. In both cases, PACT reduces the cost per solved instance, suggesting that sparse public communication is a portable efficiency mechanism even when the underlying agent loop and tool interface differ.

7 Conclusion↩︎

This paper studies what agents should pass to one another in MAS. Through diagnostic analysis across five common strategies on two MAS settings, we show that no common communication strategy is uniformly optimal, and the useful content in an inter-agent message is usually action-centered. Motivated by this, we propose PACT (Protocolized Action-state Communication and Transmission), a communication protocol that restricts shared history to compact action-state messages while excluding intermediate content. PACT only updates the content in the public messages without affecting the capability of the agent model. Across controlled MAS settings and production coding harnesses, PACT improves the performance–cost trade-off by reducing redundant context while preserving or improving task performance. These results suggest that disciplining what enters the shared inter-agent channel is itself an effective mechanism for reducing redundant context growth in inter-agent communication, and we should not merely leave it as unconstrained natural-language outputs.

Limitations↩︎

PACT is designed for MAS settings where shared conversational history is a major source of token cost, its benefits on systems with short interactions or architectures that do not repeatedly expose prior agent outputs are not fully explored. Our experiments cover two controlled MAS topologies and two agentic coding harnesses, but they do not exhaust all forms of multi-agent collaboration, such as open-ended debate, tool-heavy planning, or dynamically routed agent networks.

Appendix↩︎

8 Experimental Details↩︎

This section collects the experimental settings for both the diagnostic analysis (§3) and the PACT experiments (§5, §6). Unless noted otherwise, all runs use vLLM with sampling temperature \(0.6\) and top-\(p\) \(0.95\).

8.0.0.1 Models.

Our evaluation includes models from the Qwen3 family [33] (8B, 14B and 32B in scale), allowing us to assess performance across both mid-scale and large-scale reasoning models.

8.0.0.2 Benchmarks.

For the split-evidence interaction, we evaluate on HotpotQA [34] and 2WikiMultiHopQA [35]. For the sequential pipeline setting, we evaluate on three categories of benchmarks: (i) mathematical reasoning, including AIME2024 [36] and AIME2025 [37]; (ii) scientific reasoning, using GPQA-Diamond [38]; and (iii) commonsense question answering, using OpenBookQA [39]. We report AIME24/25 and GPQA-Diamond as avg@8 where we average over different seeds to resolve sampling noise; single-seed benchmarks use seed \(42\).

8.0.0.3 Diagnostic analysis (§3).

The diagnostic analyses evaluate five common inter-agent communication strategies in both MAS settings: Full Content, Concise Generation, Conclusion Only, Brief Summary, and Artifact Only. In the two-agent split-evidence interaction, we use a 5–5 context split, where each agent receives one gold supporting paragraph and four distractors. Agents communicate for at most \(8\) turns with early exit, and we set max_new_tokens to \(8{,}192\). The sequential pipeline uses the same five communication strategies under the fixed Planner–Critic–Refiner–Solver order, with benchmark-specific settings reported below.

8.0.0.4 PACT experiments.

The four-agent Planner\(\rightarrow\)Critic\(\rightarrow\)Refiner\(\rightarrow\)Solver pipeline (§3 Setting B, §5) and the two-agent split-evidence interaction (§5) reuse the corresponding analysis settings. The split-evidence interaction uses \(4\) alternating turns, max_new_tokens\(=4{,}096\) per turn, 5–5 split. Following [18], the per-benchmark settings are given in Table 6.

8.0.0.5 Baselines (§5).

The three MAS baselines are instantiated as follows. All baselines share the decoding settings, per-benchmark token budgets, and dataset splits described above; only the inter-agent communication protocol differs.

Chain of Agents (CoA). [8] We use the same agent counts as the corresponding MAS settings (\(2\) workers for the interaction setting, \(4\) for the pipeline). Each worker reads only the single most recent message from its predecessor—there is no rolling shared history, so the inter-agent channel carries only \(1\) round of context between consecutive workers.

Text-based MAS (TextMAS). [10] Role-specialised agents collaborating via free-form natural-language messages, with the full message history retained in the shared channel and no constraint on the message format. We instantiate it under the same MAS configurations: two symmetric agents with \(4\) alternating turns for Setting A, and the four-agent Planner\(\rightarrow\)Critic\(\rightarrow\)Refiner\(\rightarrow\)Solver schedule for Setting B.

Multi-Agent Debate. [6] \(4\) agents independently propose initial answers and then debate over \(3\) rounds, each round revising its answer conditioned on the other agents’ previous-round answers; the final answer is the majority vote across agents after the last round. The same configuration is used in both settings.

6pt

8.0.0.6 Agentic coding harnesses (§6).

OpenHands (CodeActAgent) and SWE-agent are evaluated on SWE-bench Verified with Qwen3-14B. PACT is applied as a LiteLLM proxy hook that rewrites prompts and parses responses in flight, with no SDK or docker-image changes.

9 Split-Evidence Interaction Case Study: How PACT Changes the Message↩︎

Figure 5 contrasts the same interaction turn with and without PACT on a representative HotpotQA bridge question (“Which magazine was started first, Arthur’s Magazine or First for Women?”). Without PACT—essentially the TextMAS baseline—the agent forwards its full <think> deliberation and hedged prose, so the partner re-reads hundreds of tokens of reasoning about the agent’s own paragraph. PACT keeps exactly the surfaced fact and the precise request: the ~\(10\times\) shorter message carries the same actionable content, which is why downstream turns stay accurate while the shared history stops compounding.

References↩︎