Every multi-agent pitch I hear credits the same thing: the typed contract between agents. Validate the handoff with a schema, and quality follows. A new study on a requirements-engineering pipeline tested that claim directly, and the contract came out as the smallest part of the gain. Splitting the work into two specialised prompts delivered up to +0.075 macro F1. Adding the Pydantic-validated typed state on top delivered between -0.003 and +0.013.
The paper is Beyond Accuracy: Disentangling Decomposition from Typed-State Quality Assurance in Multi-Agent LLM Pipelines, by Zuppardo and Garcia. The task is small: classify requirements as functional or non-functional, then prioritise them with MoSCoW. But the experimental design is the useful part, because it separates two things most multi-agent write-ups bundle together.
Three architectures, one deliberate control#
Most comparisons put a single-call baseline against a full orchestrated pipeline and call the difference "multi-agent." These authors added a middle rung:
Baseline: one call, one joint prompt.
Two-call: the pipeline's specialised prompts, but the intermediate result is passed as a plain unvalidated dataclass.
Pipeline: the same two agents on LangGraph, passing a Pydantic-validated typed state.
The grid is 625 PROMISE NFR+ requirements, three local 7–8B models (qwen2.5:7b, llama3.1:8b, mistral:7b via Ollama at temperature 0), and two languages, English plus a machine-translated Portuguese. That makes 18 conditions. The two-call rung is the control I wish more papers had: it holds the prompts and call count constant and varies only the typed boundary.
The prompts earned the F1, the schema earned almost none#
Full pipeline against baseline looks like a win. It was significant in 3 of 6 model-language cells, with the biggest jumps in Portuguese: qwen +0.079 (0.733 to 0.812) and llama +0.063 (0.630 to 0.693). A team running only that comparison would credit the architecture.
The decomposition shows where it came from. Going from baseline to two-call gave +0.075 on qwen PT and +0.053 on llama PT. Going from two-call to the typed pipeline gave +0.004 and +0.011 on the same cells. Across all six cells the typed step moved F1 by -0.003 to +0.013, and only one comparison (mistral EN, p = 0.0082) was significant.
the typed contract barely moves F1
That is a quote from the paper's introduction, and it is the sentence I would put on the wall of any team currently debating Pydantic versus free-form handoffs for accuracy reasons. If you want better classification from a small model, the evidence here says to write narrower prompts for narrower jobs.
There is also a language wrinkle worth noting. Portuguese was significantly lower than English in 5 of 9 architecture-model cells, even for the decomposed variants, and mistral:7b in Portuguese left 7.3% of predicted non-functional outputs without a valid category (versus 1.3 to 1.4% in English). The authors decline to claim decomposition shrinks the language gap, since the Portuguese text is machine-translated and requirement language and prompt language change together. I agree with that restraint: weaker inputs make a pipeline look more important than it is, because there is more headroom for any intervention to claim.
What the schema actually bought: a loud failure#
The authors do not conclude that typing is useless, and neither do I. They injected 13 synthetic faults, 6 value-range and 7 parse-level. The typed pipeline flagged the value-range faults after the first call, at the agent boundary. The unvalidated two-call variant did not notice until it assembled the output model after the second call. Its retry policy then reran both calls (six in total), and the requirement was dropped with no failure record.
A silent dropped item is the failure mode I fear most in agent pipelines, because the dashboards stay green. So the contract is an observability feature, not an accuracy feature. Judge it on those terms.
Where I would not lean on this#
The authors say plainly that the study is associative: the two-call contrast bundles prompt wording, an extra call and staged context, so "decomposition" is a package, not one lever. The scope is narrow. It is one dataset, three 7–8B models, one domain, and fault injection that is synthetic. In the real 18-run grid, no output fell out of range, so the validation caught nothing in production-style runs. Confidence routing fired on 3 of 3,750 predictions, which means its effect is basically untested.
A supplementary gpt-4.1-mini check agrees on direction (typed step +0.006 PT, -0.003 EN, neither significant), but it was one model, one execution, and the two language runs used different agent code versions. Whether a frontier model with native structured output behaves the same is open.
A consistency number I would treat as soft#
Fleiss' kappa for MoSCoW agreement across the three models went from -0.141 (baseline) to +0.136 (two-call) to +0.177 (pipeline) in Portuguese. The typed step added +0.041 (p = 0.0004) in PT and +0.069 in EN. A rerun reproduced the sign, but the PT increment roughly halved. There is no ground truth for priority, so this measures agreement, not correctness. I read it as a hint that the boundary may help, not a result.
What I would do with it#
For a coding-agent setup such as a planner feeding an implementer in Claude Code sub-agents, I would stop spending the first week on schema design and spend it on prompt split instead. Ablate the way this paper does: keep the specialised prompts, drop the validation, and see what you lose. If the answer is under a point of quality, keep the schema for fault detection and stop claiming it as the quality lever.
My prediction is that this pattern holds for most small-model pipelines: the decomposition does the thinking and the contract does the bookkeeping. The open question is whether it survives a frontier model, where one big prompt may already be good enough that neither piece matters.