Should Agents Talk in Prose or in Schemas?

When one agent passes work to another, the message can be natural language or a structured object. The choice looks stylistic and isn't — it determines what survives the handoff, what can be validated, and what you can debug afterwards.

What each preserves

Prose carries nuance, hedging, and reasoning. "The totals reconcile, though the third invoice has an FX discrepancy of about two euros that's probably rounding — worth confirming if precision matters" contains a judgment that no fixed schema anticipated.

Structured carries exactly the fields you defined, validated, machine-checkable:

{ reconciled: true,
  discrepancies: [{invoice: "INV-203", amount_eur: 2.04, likely_cause: "fx_rounding"}],
  confidence: "high" }

Nothing else survives. If the sender knew something the schema has no field for, it's gone.

The failure of each

Prose degrades across hops. Each receiving agent interprets, rephrases, and passes on its interpretation. By hop three the qualification has dissolved — "probably rounding, worth confirming" becomes "a rounding difference" becomes an established fact. Nothing flagged the transition from hedge to assertion.

Prose also can't be validated. A worker returning a summary that omits a required finding produces no error; it produces a plausible summary that's missing something, discovered later if at all.

Structured loses what it didn't anticipate. The schema is a hypothesis about what matters, written before anyone knew what the worker would find. Anything outside it is discarded silently — and the interesting findings are often exactly the unanticipated ones.

Rigid schemas also push senders into bad fits. A finding that's sort of a discrepancy gets forced into the discrepancy array or dropped, and neither is right.

The shape that works: structured with an escape hatch

Nearly always the answer:

{ // structured — validated, machine-checked, drives control flow
  status: "done" | "failed" | "needs_input",
  reconciled: boolean,
  discrepancies: [{...}],
  confidence: "high" | "low",

  // prose — for what the schema didn't anticipate
  notes: string,           // capped length
  flags_for_human: string[]
}

The structured fields drive the supervisor's logic. The prose field carries the rest. Two properties make this work:

The supervisor must actually read notes. If it's logged and ignored, you've built a structured protocol with a decorative text field. The notes should reach whatever aggregates or reports, and ideally the human reviewing the output.

Recurring notes become fields. ⚠️ If the same kind of observation shows up in notes repeatedly, that's a schema gap — promote it. The escape hatch is for the unanticipated, not a permanent home for something you now anticipate.

Rules of thumb

• Anything the receiver branches on → structured. Control flow should never depend on parsing prose. This is non-negotiable: a supervisor deciding what to do next based on interpreting a sentence is a system that fails in ways you can't test.
• Anything a human will read → prose, or both. Structured data is a poor report.
• Anything crossing more than one hop → structured, with provenance. Prose doesn't survive multiple interpretations.
• Uncertainty → structured, with a defined vocabulary. "Probably," "roughly," and "worth checking" mean different things to different readers, including model readers. A confidence enum with definitions is interpreted consistently.
• Evidence → structured, with quotes. A claim plus its verbatim source span, so downstream can verify rather than trust.

💡 The debugging argument

The strongest practical case for structure: when a multi-agent system produces a wrong answer, you need to know which agent introduced the error.

With structured messages, you can diff what each agent received against what it emitted, and the transformation is inspectable. With prose, every hop is a rewrite, and locating where a claim mutated means reading and comparing paragraphs — for every hop, on every investigation.

The takeaway

Structured for anything that drives control flow, crosses multiple hops, expresses uncertainty, or carries evidence. Prose in a bounded, actually-read field for what the schema didn't anticipate. Then watch what accumulates in that field: recurring notes are the schema telling you what it's missing, and promoting them is how the protocol improves.