Part IA message is a decision instrument

Classical communication theory begins with a source, a channel and a destination. Shannon's framework made it possible to reason precisely about code length, noise and channel capacity while deliberately setting aside the message's semantic purpose. [1] That abstraction remains indispensable. It does not, by itself, tell an agent which parts of an upstream investigation matter to a downstream choice.

Decision theory adds the missing relation. Blackwell compared information structures through the decisions they support: one experiment is more informative when it can perform at least as well across downstream decision problems. [2] The practical implication is severe. Information has no universal value apart from a receiver, an action set, uncertain state and consequence function.

The information bottleneck method makes relevance explicit. It seeks a compressed representation of an input that preserves information about a chosen target. [3] Multi-agent reinforcement-learning research later used related objectives to learn compact messages, targeted recipients and communication schedules under bandwidth constraints. [4] [6] [7] [9] The central design choice is therefore not the compression algorithm. It is the relevance target.

For a handoff between specialised agents, the target should usually be the receiver's decision and its evidential conditions. Let X be the sender's full relevant evidence, C the receiver's local context, M the transmitted message, A an action and S the consequential state of the world. A validated reference procedure chooses A_full from X and C. The deployed receiver chooses A_msg from M and C.

Here L is the declared loss, so a wrong release can cost more than an unnecessary referral. C(M) is not merely token count. It can include latency, inference cost, privacy exposure, storage, attack surface and the chance that irrelevant context distracts a bounded receiver. The tolerances ε and δ are release choices, not mathematical constants.

A message is decision-sufficient when further access to the sender's evidence would not improve the declared receiving decision beyond the accepted tolerance. It is operationally minimal when removing any remaining field, distinction or reference causes decision regret, a hard-constraint error or a governance failure to cross its limit.

Why more information can still hurt a real receiver

For an ideal decision maker with fixed preferences and no processing limit, access to more information cannot reduce the best achievable expected utility. A language-model agent is not that observer. It has a bounded context, finite attention, a prompt, a decoder and a tool budget. Extra upstream traces consume tokens, repeat weak claims, expose private content and can compete with the evidence the receiver must actually use.

A recent preprint compares single-agent and multi-agent language systems while holding task decomposition constant. Its proposed mechanism is a bounded relay: near-sufficient messages remove distracting context, while lossy messages reverse the gain. [12] Another preprint compares several inter-agent content strategies and reports that full content is expensive, generic brevity is unstable and conclusion-only messages depend on topology; action-state records offer a better performance-cost trade in the tested settings. [11]

Compression helps only when it removes interference faster than it removes decision-relevant information. Whether that inequality holds depends on the task, sender, receiver, topology and loss. It must be measured at the actual handoff.

Decision sufficiency is not textual reconstruction

A reconstruction objective asks whether the receiver can recover the source. A decision objective asks whether the receiver can choose well. The first is often much harder. A payment dossier may contain hundreds of facts, but only a few may distinguish release from escalation under the current policy. Requiring the message to reproduce the dossier wastes channel capacity and encourages the sender to forward narrative that the receiver neither needs nor can reliably verify.

The reverse mistake is to preserve whatever looks statistically informative. Mutual information can reward features that predict the source or the action on average while missing an asymmetric boundary. Suppose customer segment strongly predicts routine release, but a rare sanctions flag overrides every segment. A compact representation optimised for average prediction may spend its bits on segment and discard the rare override. It compresses the dataset well and the decision badly.

A decision-oriented encoder therefore needs more than a target label. It needs the action set, the consequence of each error, hard constraints and enough support for the receiver to determine whether the case belongs near a boundary. In the strongest form, the message preserves not merely today's chosen action but the local counterfactual: which feasible change in evidence, policy or authority would change that action.

This also clarifies the role of calibration. A confidence number is useful only when the receiver has a calibrated mapping from that number to an action or information-seeking step. “Ninety per cent confident” is not self-interpreting. It may be enough for a reversible content recommendation and radically inadequate for an irreversible payment. Decision sufficiency is always indexed by consequence, not by a generic notion of semantic completeness.

flowchart TD
  A["The dossier and the decision"] --> B["On this page"]
  B --> C["Part I A message is a decision<br/>instrument"]
  C --> D["Part II The smallest message<br/>is a partition"]
  D -. "re-test" .-> A
  classDef first fill:#0a1424,stroke:#B96D00,stroke-width:2px,color:#e6f3ff
  classDef step fill:#0a1424,stroke:#3f7da0,stroke-width:1px,color:#e6f3ff
  class A first
  class B,C,D step

Part IIThe smallest message is a partition

Imagine that every possible upstream evidence state is a point on a large landscape. The receiver's policy divides that landscape into regions: release here, hold there, escalate beyond this boundary. Two evidence states are equivalent for this decision when they lead to the same optimal action, the same authority requirement and the same minimum evidence obligation.

The encoder need not reconstruct every coordinate. It needs to identify the correct equivalence region and provide a certificate the receiver can verify. In the opening case, exact transaction narration may be irrelevant, while the single bit “policy current” separates release from escalation. A field's importance is therefore determined by the shape of the decision boundary, not by its length, salience or frequency in the source.

Thought experiment: the scout, the pilot and a new action

A scout drone sees a detailed terrain map. A pilot approaching a fork can choose only left or right. The left path is blocked and the right path is open. A one-bit message, “right”, is enough if the scout is authorised to choose the turn. If the pilot must verify the recommendation, it also needs obstacle location, observation time and confidence.

Now give the pilot two new actions: stop and land. The source evidence does not change. Low visibility, previously irrelevant because the pilot had to choose a branch, may now make landing optimal. The old one-bit message has become insufficient even though it remains factually correct.

Only one causal feature changed: the action set. This reveals a general rule: sufficiency belongs to a receiver-decision pair, not to a message in isolation. Add an action, alter the cost of delay, give the receiver a fresh sensor or remove its policy access, and the equivalence regions split or merge.

Thought experiment: the same evidence under a different loss

A maintenance specialist estimates the probability that a pump will fail during the next operating window. The receiver has two actions: continue or stop for inspection. Stopping has a fixed cost of two units. Continuing has expected loss p × h, where p is failure probability and h is the consequence of failure. The controller should stop when p exceeds 2/h.

First set h to 10. The threshold is 0.20. A coarse message saying “failure probability is below 10 per cent” is sufficient because every represented state remains on the continue side. Whether the estimate is 0.03 or 0.08 cannot change this decision.

Now change only the consequence of failure. The pump feeds a safety-critical cooling loop, so h rises to 40 and the threshold falls to 0.05. The old message now collapses states demanding different actions. An estimate of 0.03 supports continuing; 0.08 supports stopping. The evidence and action set stayed fixed. The loss changed.

The receiver does not automatically need more digits. It needs a value or interval precise enough not to straddle its threshold, plus the assumptions that locate that threshold. A certified interval of [0.01, 0.04] may suffice, while a point estimate of 0.04 without calibration or validity may not. Minimality follows the consequence surface.

What must survive compression

A useful handoff has two layers. The semantic layer preserves distinctions that can change action or expected loss. The operational layer preserves what makes that action admissible, attributable and reconstructable. Confusing them creates opposite errors.

A message can be semantically adequate but operationally invalid. “Hold” may be correct, yet the receiver cannot act because the request expired, the sender lacks authority or the evidence reference is inaccessible. Conversely, a message can pass a schema while being semantically false. A well-typed field saying policy_current: true does not prove the policy is current.

For a consequential receiver, compact public state usually needs seven kinds of content:

1. Action or requested next step. State what the sender concluded and what the receiver is being asked to decide.
2. Decisive state. Carry the smallest facts whose values locate the case in the correct decision region.
3. Evidence references. Point to authoritative records so the receiver can verify, refresh or contest each consequential claim.
4. Uncertainty, conflict and missingness. Preserve unresolved alternatives rather than laundering them into smooth prose.
5. Policy and effective time. Name the rule version, observation time and validity window that make the state applicable.
6. Identity and authority. Distinguish who investigated, who proposed, who may approve and who may execute.
7. Counterfactual trigger. State which change would require recomputation rather than reusing the receipt.

The list is not a universal schema. It is a set of candidate obligations to test. A low-consequence routing agent may need fewer. A regulated decision may require lineage, source trust class, reason codes or a human attestation. The field earns its place by surviving an ablation test, not by sounding prudent.

The receiver's context carries part of the message

A message can be short because the receiver already knows something. If the case owner has an authenticated policy service, the sender may transmit a policy identifier and effective time rather than copying the rule text. If the receiver has no access to that service, the same identifier is an unusable pointer. The apparent compression is therefore partly a transfer into receiver context.

That observation matters when teams compare message formats. A compact handoff may look superior because its benchmark silently gives the receiver shared memory, hidden system instructions or direct access to the original record. Another architecture may count those bytes honestly. Fair comparison requires a complete boundary inventory: what is in the message, what is local context, what can be retrieved, what is cached and what authority is ambient.

The safest contract names its context dependencies. It can declare that the receiver must resolve policy version PAY-7.4, possess the case-owner role and use a screening result no older than a stated threshold. If any dependency is missing, the receiver should reject or escalate rather than improvise. This turns hidden assumptions into testable preconditions.

Context can also make a previously sufficient message fail. A receiver upgrade may change prompt wording, tool availability or interpretation of an enum. A cache may retain an obsolete policy. A local record may contradict the sender's state. The handoff should not attempt to absorb every possibility. It should carry enough identity, time and evidence references for the receiver to detect the mismatch. A minimum message is the minimum over the message plus declared receiver context, never over the message alone.

{
  "case_id": "case-1842",
  "sender": "evidence-specialist",
  "receiver": "case-owner",
  "authority": "ADVISE",
  "proposed_action": "ESCALATE",
  "decision_state": {
    "identity_verified": true,
    "screening_clear": true,
    "duplicate_signal": false,
    "policy_current": false,
    "evidence_conflict": false,
    "high_value": false
  },
  "evidence_refs": ["evidence://.../policy"],
  "policy_version": "PAY-7.4",
  "valid_until": "...",
  "counterfactual_trigger": "recompute on change"
}

Part IIIAblate until the decision changes

A summary metric cannot establish sufficiency. ROUGE, semantic similarity, factual overlap and compression ratio compare messages with source text. The causal question is different: what happens to the receiving decision when a field or distinction disappears?

Lowe and colleagues showed an analogous problem in emergent communication: correlation between messages and actions can suggest meaningful communication even when interventions reveal that the message has little causal effect. [8] For an engineered handoff, the remedy is direct. Hold the receiver fixed, manipulate the channel and measure action, regret and hard violations.

A release experiment in seven steps

1. Declare the receiver. Freeze its prompt or policy, tools, model route, local context and action set.
2. Build a full-evidence baseline. Establish the best defensible action available under the same information and authority.
3. Specify consequence. Use an asymmetric loss matrix and separate hard constraints from average regret.
4. Encode a candidate message. Include semantic fields and operational gates explicitly.
5. Ablate and coarsen. Remove one field, merge values, reduce precision and shorten references.
6. Mutate values. Inject plausible, schema-valid errors to test whether structure is being confused with truth.
7. Change the boundary. Repeat under policy changes, a weaker receiver, more hops, new actions and an authoritative sender.

Measure at least three outputs. Decision agreement shows whether the action matches the reference. Consequence-weighted regret distinguishes a harmless extra referral from an unsafe release. Hard violations count events that cannot be averaged away. Message bytes, tokens and latency then describe the cost side of the frontier.

Baselines that can falsify the architecture

Before optimising a relay, test whether the relay is doing useful work. A no-message control reveals what the receiver can infer from local context alone. A shuffled-message control reveals whether message content matters or whether the workflow merely benefits from another model call. A constant-message control detects cases where the receiver ignores the channel while appearing to collaborate.

Then compare stronger alternatives. A full-evidence receiver establishes the information ceiling. Direct retrieval lets the receiver fetch authoritative facts without trusting a summary. A single-agent baseline removes the relay and keeps one context. A deterministic rule or calculation may solve the decision without generative communication. Human review defines the accountable fallback where uncertainty and consequence justify it.

These controls distinguish four explanations that otherwise look alike. The sender may contribute genuinely complementary evidence. The extra call may add test-time compute rather than specialisation. The relay may reduce distracting context. Or the receiver may simply follow a second opinion, regardless of its content. Only interventions separate them.

The most important control is authority. Give the sender final decision rights and make the receiver an actuator. If an action-only message now succeeds, the test confirms that evidential fields were needed for receiver judgement rather than for transport. This is a useful negative control, but it also warns against an easy benchmark trick: moving the decision boundary can make a message look sufficient without preserving the original accountability design.

Worked example: a synthetic message-ablation laboratory

The executable artefact below creates 28 balanced synthetic cases. Four variants are generated for each of seven scenarios: routine, unverified identity, uncleared screening, duplicate signal, stale policy, conflicting evidence and high value. The reference receiver chooses release, hold, reject as duplicate or escalate. A synthetic loss matrix makes unsafe release much more costly than unnecessary escalation.

Five handoffs are compared. The full record sends every field and repeated evidence text. The decision contract sends six decisive fields plus identity, evidence, validity and authority. A scalar risk score compresses distinct reasons into one number. An advisory action-only message asks the receiver to trust a verdict it is not authorised to execute. The negative control changes the sender's authority to DECIDE, turning the receiver into an actuator.

The typed contract and full record make the same decision on every fixture. The contract averages 624 serialised JSON bytes against 3,018 for the deliberately verbose record. The risk score is smaller, but agreement falls because one scalar cannot preserve distinct action classes. The advisory action-only message agrees only on routine cases where an accountable receiver's conservative escalation happens to match the reference.

The authoritative action-only negative control reaches full agreement in about 299 bytes. This is not evidence that action-only messages are generally best. It confirms the boundary: once final authority moves to the sender, the receiver's decision disappears. The apparent communication improvement came from changing the architecture.

Field ablation reveals why average agreement is a weak release test. Removing any one decision field leaves 85.7 per cent of cases unchanged because only four fixtures make that field decisive. A benchmark dominated by routine cases could therefore report high agreement while hiding every consequential failure. Under unsafe benign defaults, each omission produces four catastrophic errors. Policy currency, evidence conflict and high-value status carry the largest mean regret in this synthetic matrix.

Schema-valid is not truth-valid

The lab also injects one well-typed false value. In a case that should escalate because its policy is stale, policy_current is changed to true. The message still passes structural validation and the receiver releases the case, incurring the maximum synthetic loss of 120. The schema has done its job: it localised the error to one named field. It did not establish truth.

A controlled preprint studying multi-hop language-model relays reaches a related conclusion in its testbed. Message format affects fidelity differently across model tiers; a fixed-key JSON format can resist drift for a weaker relay, yet an injected wrong value can remain faithfully present through the chain. [13] Structure is a faithful channel, not an error-correcting oracle. Evidence readback and independent verification remain necessary.

#!/usr/bin/env python3
"""Decision-sufficient communication laboratory.

The lab compares five handoff strategies on balanced synthetic cases. It asks
whether a smaller message preserves the receiving decision under an asymmetric
loss function and an explicit authority contract.

Python 3.10+. Standard library only. Synthetic data only.
"""
from __future__ import annotations

from dataclasses import asdict, dataclass, replace
from enum import Enum
import json
from statistics import mean
from typing import Any, Callable, Iterable


class Action(str, Enum):
    RELEASE = "RELEASE"
    HOLD = "HOLD"
    REJECT_DUPLICATE = "REJECT_DUPLICATE"
    ESCALATE = "ESCALATE"


DECISION_FIELDS = (
    "identity_verified",
    "screening_clear",
    "duplicate_signal",
    "policy_current",
    "evidence_conflict",
    "high_value",
)
GOVERNANCE_FIELDS = (
    "case_id",
    "sender",
    "receiver",
    "authority",
    "policy_version",
    "valid_until",
    "evidence_refs",
)


@dataclass(frozen=True)
class Case:
    case_id: str
    identity_verified: bool
    screening_clear: bool
    duplicate_signal: bool
    policy_current: bool
    evidence_conflict: bool
    high_value: bool
    amount: int
    counterparty: str
    history: str
    evidence_refs: tuple[str, ...]


@dataclass(frozen=True)
class Receipt:
    case_id: str
    sender: str
    receiver: str
    authority: str
    proposed_action: str
    decision_state: dict[str, bool]
    evidence_refs: tuple[str, ...]
    policy_version: str
    valid_until: str
    uncertainty: str
    counterfactual_trigger: str


LOSS: dict[tuple[Action, Action], int] = {
    # (chosen, reference) -> synthetic consequence units
    (Action.RELEASE, Action.RELEASE): 0,
    (Action.HOLD, Action.HOLD): 0,
    (Action.REJECT_DUPLICATE, Action.REJECT_DUPLICATE): 0,
    (Action.ESCALATE, Action.ESCALATE): 0,
    (Action.ESCALATE, Action.RELEASE): 2,
    (Action.HOLD, Action.RELEASE): 4,
    (Action.REJECT_DUPLICATE, Action.RELEASE): 15,
    (Action.RELEASE, Action.ESCALATE): 120,
    (Action.RELEASE, Action.HOLD): 100,
    (Action.RELEASE, Action.REJECT_DUPLICATE): 80,
    (Action.HOLD, Action.ESCALATE): 8,
    (Action.HOLD, Action.REJECT_DUPLICATE): 25,
    (Action.REJECT_DUPLICATE, Action.HOLD): 35,
    (Action.REJECT_DUPLICATE, Action.ESCALATE): 30,
    (Action.ESCALATE, Action.HOLD): 5,
    (Action.ESCALATE, Action.REJECT_DUPLICATE): 6,
}


def policy(state: dict[str, bool]) -> Action:
    """Deterministic reference policy; ordering encodes precedence."""
    if not state["identity_verified"]:
        return Action.HOLD
    if not state["screening_clear"]:
        return Action.HOLD
    if state["duplicate_signal"]:
        return Action.REJECT_DUPLICATE
    if not state["policy_current"]:
        return Action.ESCALATE
    if state["evidence_conflict"]:
        return Action.ESCALATE
    if state["high_value"]:
        return Action.ESCALATE
    return Action.RELEASE


def state_of(case: Case) -> dict[str, bool]:
    return {field: bool(getattr(case, field)) for field in DECISION_FIELDS}


def build_cases() -> list[Case]:
    """Four variants for seven independently decisive scenarios."""
    scenarios = [
        ("routine", {}),
        ("identity", {"identity_verified": False}),
        ("screening", {"screening_clear": False}),
        ("duplicate", {"duplicate_signal": True}),
        ("policy", {"policy_current": False}),
        ("conflict", {"evidence_conflict": True}),
        ("value", {"high_value": True}),
    ]
    cases: list[Case] = []
    for scenario, changes in scenarios:
        for variant in range(4):
            base: dict[str, Any] = {
                "case_id": f"{scenario}-{variant+1:02d}",
                "identity_verified": True,
                "screening_clear": True,
                "duplicate_signal": False,
                "policy_current": True,
                "evidence_conflict": False,
                "high_value": False,
                "amount": 9_000 + variant * 1_750,
                "counterparty": f"Synthetic Counterparty {variant+1}",
                "history": (
                    "Synthetic history repeated to model a verbose dossier. "
                    "It is deliberately irrelevant to this declared policy. "
                ) * (6 + variant),
                "evidence_refs": (
                    f"evidence://{scenario}/{variant+1}/identity",
                    f"evidence://{scenario}/{variant+1}/screening",
                    f"evidence://{scenario}/{variant+1}/policy",
                ),
            }
            base.update(changes)
            if scenario == "value":
                base["amount"] = 175_000 + variant * 25_000
            cases.append(Case(**base))
    return cases


def serialised_bytes(payload: dict[str, Any]) -> int:
    return len(json.dumps(payload, sort_keys=True, separators=(",", ":")).encode())


def full_record(case: Case) -> dict[str, Any]:
    payload = asdict(case)
    payload.update(
        {
            "sender": "evidence-specialist",
            "receiver": "case-owner",
            "authority": "ADVISE",
            "policy_version": "PAY-7.4",
            "valid_until": "2027-01-01T00:00:00Z",
            "proposed_action": policy(state_of(case)).value,
            "investigation_notes": case.history * 2,
        }
    )
    return payload


def decision_contract(case: Case, authority: str = "ADVISE") -> dict[str, Any]:
    state = state_of(case)
    receipt = Receipt(
        case_id=case.case_id,
        sender="evidence-specialist",
        receiver="case-owner",
        authority=authority,
        proposed_action=policy(state).value,
        decision_state=state,
        evidence_refs=case.evidence_refs,
        policy_version="PAY-7.4",
        valid_until="2027-01-01T00:00:00Z",
        uncertainty="CONFLICT" if case.evidence_conflict else "RESOLVED",
        counterfactual_trigger=(
            "Recompute if any decision_state field, policy version, evidence status, "
            "authority or action set changes."
        ),
    )
    return asdict(receipt)


def risk_score(case: Case) -> dict[str, Any]:
    state = state_of(case)
    score = (
        35 * (not state["identity_verified"])
        + 35 * (not state["screening_clear"])
        + 45 * state["duplicate_signal"]
        + 25 * (not state["policy_current"])
        + 25 * state["evidence_conflict"]
        + 20 * state["high_value"]
    )
    return {
        "case_id": case.case_id,
        "sender": "evidence-specialist",
        "receiver": "case-owner",
        "authority": "ADVISE",
        "risk_score": score,
        "evidence_refs": case.evidence_refs,
        "policy_version": "PAY-7.4",
        "valid_until": "2027-01-01T00:00:00Z",
    }


def action_only(case: Case, authority: str) -> dict[str, Any]:
    return {
        "case_id": case.case_id,
        "sender": "evidence-specialist",
        "receiver": "case-owner",
        "authority": authority,
        "action": policy(state_of(case)).value,
        "evidence_refs": case.evidence_refs,
        "policy_version": "PAY-7.4",
        "valid_until": "2027-01-01T00:00:00Z",
    }


def governance_valid(message: dict[str, Any]) -> bool:
    return all(message.get(field) not in (None, "", [], ()) for field in GOVERNANCE_FIELDS)


def receive_full(message: dict[str, Any]) -> Action:
    state = {field: bool(message[field]) for field in DECISION_FIELDS}
    return policy(state)


def receive_contract(message: dict[str, Any]) -> Action:
    if not governance_valid(message):
        return Action.ESCALATE
    if message.get("authority") == "DECIDE" and "action" in message:
        return Action(message["action"])
    state = message.get("decision_state")
    if not isinstance(state, dict) or any(field not in state for field in DECISION_FIELDS):
        return Action.ESCALATE
    return policy({field: bool(state[field]) for field in DECISION_FIELDS})


def receive_score(message: dict[str, Any]) -> Action:
    # A scalar cannot preserve the reason-specific action classes.
    score = int(message["risk_score"])
    return Action.RELEASE if score < 20 else Action.ESCALATE


def receive_action_advisory(message: dict[str, Any]) -> Action:
    # Accountable receiver refuses an unsupported advisory verdict.
    return Action.ESCALATE


def receive_action_authoritative(message: dict[str, Any]) -> Action:
    if not governance_valid(message) or message.get("authority") != "DECIDE":
        return Action.ESCALATE
    return Action(message["action"])


@dataclass(frozen=True)
class Strategy:
    name: str
    encode: Callable[[Case], dict[str, Any]]
    receive: Callable[[dict[str, Any]], Action]


def evaluate(cases: Iterable[Case], strategy: Strategy) -> dict[str, Any]:
    agreements: list[int] = []
    regrets: list[int] = []
    catastrophic = 0
    governance: list[int] = []
    sizes: list[int] = []
    for case in cases:
        reference = policy(state_of(case))
        message = strategy.encode(case)
        chosen = strategy.receive(message)
        loss = LOSS[(chosen, reference)]
        agreements.append(int(chosen == reference))
        regrets.append(loss)
        catastrophic += int(loss >= 80)
        governance.append(int(governance_valid(message)))
        sizes.append(serialised_bytes(message))
    return {
        "strategy": strategy.name,
        "agreement": mean(agreements),
        "mean_regret": mean(regrets),
        "catastrophic_errors": catastrophic,
        "governance_pass_rate": mean(governance),
        "mean_bytes": mean(sizes),
    }


def ablate_decision_field(cases: list[Case], removed: str) -> dict[str, Any]:
    agreements: list[int] = []
    regrets: list[int] = []
    catastrophic = 0
    for case in cases:
        reference = policy(state_of(case))
        message = decision_contract(case)
        # Unsafe benign default makes the omission visible in the test.
        defaults = {
            "identity_verified": True,
            "screening_clear": True,
            "duplicate_signal": False,
            "policy_current": True,
            "evidence_conflict": False,
            "high_value": False,
        }
        message["decision_state"].pop(removed)
        reconstructed = {**defaults, **message["decision_state"]}
        chosen = policy(reconstructed)
        loss = LOSS[(chosen, reference)]
        agreements.append(int(chosen == reference))
        regrets.append(loss)
        catastrophic += int(loss >= 80)
    return {
        "removed_field": removed,
        "agreement": round(mean(agreements), 4),
        "mean_regret": round(mean(regrets), 4),
        "catastrophic_errors": catastrophic,
    }


def ablate_governance_field(cases: list[Case], removed: str) -> dict[str, Any]:
    semantic_agreement: list[int] = []
    strict_agreement: list[int] = []
    failures = 0
    for case in cases:
        reference = policy(state_of(case))
        message = decision_contract(case)
        message.pop(removed, None)
        semantic = policy(message["decision_state"])
        strict = receive_contract(message)
        semantic_agreement.append(int(semantic == reference))
        strict_agreement.append(int(strict == reference))
        failures += int(not governance_valid(message))
    return {
        "removed_field": removed,
        "semantic_agreement": mean(semantic_agreement),
        "strict_receiver_agreement": mean(strict_agreement),
        "governance_failures": failures,
    }


def injected_error(cases: list[Case]) -> dict[str, Any]:
    case = next(c for c in cases if c.case_id == "policy-01")
    message = decision_contract(case)
    baseline = receive_contract(message)
    message["decision_state"]["policy_current"] = True
    altered = receive_contract(message)
    reference = policy(state_of(case))
    return {
        "case_id": case.case_id,
        "schema_still_valid": governance_valid(message),
        "reference_action": reference.value,
        "baseline_action": baseline.value,
        "altered_action": altered.value,
        "synthetic_loss": LOSS[(altered, reference)],
    }


def run() -> dict[str, Any]:
    cases = build_cases()
    strategies = [
        Strategy("full_record", full_record, receive_full),
        Strategy("decision_contract", decision_contract, receive_contract),
        Strategy("risk_score", risk_score, receive_score),
        Strategy(
            "action_only_advisory",
            lambda c: action_only(c, "ADVISE"),
            receive_action_advisory,
        ),
        Strategy(
            "action_only_authoritative",
            lambda c: action_only(c, "DECIDE"),
            receive_action_authoritative,
        ),
    ]
    output = {
        "assumptions": {
            "cases": len(cases),
            "case_mix": "Four synthetic variants for each of seven independently decisive scenarios.",
            "receiver": "Advisory messages are recomputed; signed DECIDE messages are executed.",
            "loss": "Synthetic asymmetric matrix; unsafe release costs more than unnecessary escalation.",
        },
        "strategy_results": [evaluate(cases, s) for s in strategies],
        "decision_field_ablation": [ablate_decision_field(cases, f) for f in DECISION_FIELDS],
        "governance_field_ablation": [ablate_governance_field(cases, f) for f in GOVERNANCE_FIELDS],
        "error_injection": injected_error(cases),
    }

    by_name = {row["strategy"]: row for row in output["strategy_results"]}
    assert by_name["full_record"]["agreement"] == 1
    assert by_name["decision_contract"]["agreement"] == 1
    assert by_name["decision_contract"]["mean_bytes"] < by_name["full_record"]["mean_bytes"]
    assert by_name["action_only_authoritative"]["agreement"] == 1  # negative control
    assert by_name["action_only_advisory"]["agreement"] < 1
    assert output["error_injection"]["schema_still_valid"] is True
    assert output["error_injection"]["altered_action"] != output["error_injection"]["reference_action"]
    return output


if __name__ == "__main__":
    print(json.dumps(run(), indent=2))

{
  "assumptions": {
    "cases": 28,
    "case_mix": "Four synthetic variants for each of seven independently decisive scenarios.",
    "receiver": "Advisory messages are recomputed; signed DECIDE messages are executed.",
    "loss": "Synthetic asymmetric matrix; unsafe release costs more than unnecessary escalation."
  },
  "strategy_results": [
    {
      "strategy": "full_record",
      "agreement": 1,
      "mean_regret": 0,
      "catastrophic_errors": 0,
      "governance_pass_rate": 1,
      "mean_bytes": 3017.5
    },
    {
      "strategy": "decision_contract",
      "agreement": 1,
      "mean_regret": 0,
      "catastrophic_errors": 0,
      "governance_pass_rate": 1,
      "mean_bytes": 623.5714285714286
    },
    {
      "strategy": "risk_score",
      "agreement": 0.5714285714285714,
      "mean_regret": 2.2857142857142856,
      "catastrophic_errors": 0,
      "governance_pass_rate": 1,
      "mean_bytes": 294.57142857142856
    },
    {
      "strategy": "action_only_advisory",
      "agreement": 0.42857142857142855,
      "mean_regret": 2.5714285714285716,
      "catastrophic_errors": 0,
      "governance_pass_rate": 1,
      "mean_bytes": 298.57142857142856
    },
    {
      "strategy": "action_only_authoritative",
      "agreement": 1,
      "mean_regret": 0,
      "catastrophic_errors": 0,
      "governance_pass_rate": 1,
      "mean_bytes": 298.57142857142856
    }
  ],
  "decision_field_ablation": [
    {
      "removed_field": "identity_verified",
      "agreement": 0.8571,
      "mean_regret": 14.2857,
      "catastrophic_errors": 4
    },
    {
      "removed_field": "screening_clear",
      "agreement": 0.8571,
      "mean_regret": 14.2857,
      "catastrophic_errors": 4
    },
    {
      "removed_field": "duplicate_signal",
      "agreement": 0.8571,
      "mean_regret": 11.4286,
      "catastrophic_errors": 4
    },
    {
      "removed_field": "policy_current",
      "agreement": 0.8571,
      "mean_regret": 17.1429,
      "catastrophic_errors": 4
    },
    {
      "removed_field": "evidence_conflict",
      "agreement": 0.8571,
      "mean_regret": 17.1429,
      "catastrophic_errors": 4
    },
    {
      "removed_field": "high_value",
      "agreement": 0.8571,
      "mean_regret": 17.1429,
      "catastrophic_errors": 4
    }
  ],
  "governance_field_ablation": [
    {
      "removed_field": "case_id",
      "semantic_agreement": 1,
      "strict_receiver_agreement": 0.42857142857142855,
      "governance_failures": 28
    },
    {
      "removed_field": "sender",
      "semantic_agreement": 1,
      "strict_receiver_agreement": 0.42857142857142855,
      "governance_failures": 28
    },
    {
      "removed_field": "receiver",
      "semantic_agreement": 1,
      "strict_receiver_agreement": 0.42857142857142855,
      "governance_failures": 28
    },
    {
      "removed_field": "authority",
      "semantic_agreement": 1,
      "strict_receiver_agreement": 0.42857142857142855,
      "governance_failures": 28
    },
    {
      "removed_field": "policy_version",
      "semantic_agreement": 1,
      "strict_receiver_agreement": 0.42857142857142855,
      "governance_failures": 28
    },
    {
      "removed_field": "valid_until",
      "semantic_agreement": 1,
      "strict_receiver_agreement": 0.42857142857142855,
      "governance_failures": 28
    },
    {
      "removed_field": "evidence_refs",
      "semantic_agreement": 1,
      "strict_receiver_agreement": 0.42857142857142855,
      "governance_failures": 28
    }
  ],
  "error_injection": {
    "case_id": "policy-01",
    "schema_still_valid": true,
    "reference_action": "ESCALATE",
    "baseline_action": "ESCALATE",
    "altered_action": "RELEASE",
    "synthetic_loss": 120
  }
}

Part IVTurn the handoff into a contract

An experiment identifies which distinctions the receiver needs. Production engineering must keep those distinctions stable across versions, model routes, policy changes and incidents. The handoff therefore becomes a versioned contract with a release test attached to every field.

JSON Schema can require names, types, enumerations and conditional shapes. [14] It cannot decide whether a source is authoritative, whether a policy remains applicable or whether an upstream model invented a value. Separate four operations: encode the message, validate structure, resolve or verify evidence, and apply the receiving policy.

Production-shaped example: evidence specialist to case owner

Consider an evidence specialist that reconciles documents and tool results, then hands a case to an accountable owner. The specialist proposes “escalate” because two authoritative sources disagree. A generic summary often blends the conflict into one narrative. A decision receipt carries both claims, source identifiers, effective times and an explicit conflict flag. The owner can gather more evidence, apply a precedence rule or refer the conflict without reconstructing the investigation from prose.

The specialist's private reasoning is not itself evidence. It may use a long scratchpad, several retrievals and a model-specific internal process. The public handoff should expose claims, source references, calculations, unresolved alternatives and tool outcomes. This protects freedom inside the specialist while keeping the boundary inspectable.

The same separation limits prompt injection and ambient authority. Untrusted document text may inform a claim, but it cannot set authority, extend valid_until or create an executable command. Those fields come from deterministic identity and policy services. Existing site work treats typed handoffs and controlled topologies as broader production boundaries; this article narrows that architecture into a testable message criterion. [15] [16]

Temporal and multi-hop sufficiency

Sufficiency at one hop is not automatically transitive. Agent A may send Agent B exactly what B needs. B may then summarise its own conclusion for Agent C and discard a field that was irrelevant to B but decisive for C. The end-to-end channel fails even though each local sender believes it has been concise.

Multi-hop systems also re-encode values. Natural language can soften a conflict into a preference. A numeric interval can become a point estimate. A source identifier can become an unattributed claim. Repetition may preserve the broad conclusion while changing the atomic value that authorises the final action. The relay test should therefore track atomic facts, provenance, uncertainty and authority separately from overall semantic similarity.

Time adds another partition. A fact may be true at event time yet inapplicable at decision time. The message needs enough temporal state to distinguish when the source observed the fact, when the system learned it, which policy was effective and when the receipt expires. A downstream agent should not revive an old authorisation merely because the message remains in memory.

There are two sound patterns. Either every hop carries a stable decision receipt and adds a new signed transformation, or downstream agents dereference authoritative evidence and recompute for their own decisions. Repeated free-form summarisation is the weakest option because omissions become difficult to attribute. Test both local sufficiency at every edge and end-to-end sufficiency at the final consequential action.

Release matrix

The practical instrument below prevents compression ratio from becoming the release goal. A handoff is released only when the receiver preserves action and admissibility under the strongest relevant perturbations.

Monitor the boundary, not only the token bill

After release, communication metrics should remain tied to outcomes. Track bytes or tokens, but also disagreement against sampled readback, escalation quality, missing-field rejection, source-resolution failure, expired-message rejection and the distribution of counterfactual triggers. A sudden reduction in message size may be a regression if it comes from omitted state.

Version the sender encoder and receiver decoder together. A model upgrade can change how compact state is interpreted even when the JSON is unchanged. The controlled relay preprint found format effects differing across stronger and weaker model tiers. [13] That is enough to reject an assumption of automatic transfer across model routes.

Do not average away irreversible failures. Report unweighted agreement for visibility, consequence-weighted regret for decision quality and hard violations as a separate low-tolerance gate. A handoff that is 99 per cent accurate and wrong on every release boundary is not nearly sufficient.

What would weaken the proposal?

The argument would weaken if controlled studies repeatedly found generic full-context forwarding matching or exceeding decision-specific contracts after cost, privacy, latency and receiver capability were held constant. It would also weaken if field ablation proved so unstable under ordinary policy updates that contract maintenance cost exceeded direct retrieval from authoritative sources.

A stronger challenge is that language-model reasoning may use subtle interactions that resist stable fields. A rigid contract could erase novelty before the receiver sees it. The response is empirical: keep exploratory analysis private or attach an optional bounded narrative, then test whether it changes decisions beyond the typed state. If it does, the contract is incomplete. If the interaction cannot be stabilised, use shared evidence, a joint workspace or one accountable agent rather than pretending a brittle relay is sufficient.

stateDiagram-v2
  [*] --> Claim
  state "Why more information can still<br/>hurt a real receiver" as Claim
  state "Decision sufficiency is not<br/>textual reconstruction" as Test
  state "Thought experiment: the scout,<br/>the pilot and a new action" as Revision
  Claim --> Test: expose mechanism
  Test --> Decision: evidence survives
  Test --> Revision: rival survives
  Revision --> Claim: narrow or rebuild
  Decision --> [*]

Compact glossary

Decision sufficiency

Preserving the receiver's action and consequence within a declared tolerance.

Decision receipt

A typed public handoff containing proposal, decisive state, evidence, validity and authority.

Decision regret

Additional loss caused by deciding from the message rather than the full reference evidence.

Hard violation

A constraint breach counted separately from average loss.

Decision partition

Equivalence classes of source states that permit the same action and obligations.

Counterfactual trigger

A named change that invalidates reuse and requires recomputation.

Stop where the decision survives

Multi-agent systems invite a tempting question: how can agents talk more naturally? The engineering question is narrower. What must cross this boundary so that this receiver, under this policy and authority, makes a defensible decision?

The answer begins with a full-evidence baseline and ends with intervention. Compress upstream state into a decision receipt. Remove one field at a time. Coarsen values. Inject plausible errors. Change the action set, policy, model route and hop count. Compare direct retrieval, a single agent and an authoritative action-only sender. Keep every distinction whose removal changes consequence or admissibility. Remove the rest.

The minimum message is reached when another byte can disappear only by changing the decision, hiding its basis or moving authority. That criterion changes multi-agent architecture from conversational roles into measured information boundaries. It also gives each boundary a release artefact: a message contract, an ablation record and a declared regret budget.

The practical decision is clear. Do not approve an inter-agent channel because its schema validates, its summary reads well or its average accuracy is high. Approve it when the receiving decision survives the strongest relevant omissions and mutations, and when the evidence needed to contest that decision remains reachable.