DEV Community

Cover image for Composer Harness
Azan Hyder
Azan Hyder

Posted on

Composer Harness

#python #ai #productivity #programming

Field notes on the missing layer of the agent stack.

The fastest standardization in dev tool history

Eighteen months ago, "how does an agent call a tool?" had no standard answer. Every framework invented its own. Then the industry speedran one:

  • November 2024. Anthropic open sources MCP.
  • March 2025. OpenAI adopts it across ChatGPT and the Agents SDK.
  • April 2025. Google announces A2A with 50+ launch partners.
  • August 2025. IBM's ACP merges into A2A. The protocols are already consolidating.
  • Late 2025. Both MCP and A2A land at the Linux Foundation.

By December 2025, Anthropic's ecosystem update was counting 10,000+ active public MCP servers and 97M+ monthly SDK downloads. The official registry hovers near 10K records. Around 16,000 GitHub repos carry the mcp-server topic. A2A passed 150 supporting organizations by April 2026.

The protocols won. Faster than REST won, by most measures.

And yet every real stack is held together by hand

Here is the thing the adoption numbers hide: nobody runs one protocol.

Industry survey data puts the typical MCP environment at 2 to 7 configured servers. A serious deployment also runs long lived agent to agent tasks, A2A's entire reason to exist, since MCP is the wrong shape for stateful, multi turn delegation. Then there is the long tail of software that has no API at all and gets driven through computer use.

Each of those pairs is connected by hand written glue. Bespoke routing. Bespoke auth handoffs. Bespoke output parsing. Bespoke retry logic. Every team writes it, every team maintains it, none of it is shared.

The community saw this coming. When A2A launched, the top reaction was essentially: "We already have MCP. Why do we need another standard?" The honest answer is that they solve different halves of the problem. The honest problem is that nobody standardized the layer that composes them.

And it is not a theoretical pain. Zuplo's State of MCP 2025 report found security and access control is the #1 blocker to MCP in production, ahead of any capability gap. The tools work. Operating them together doesn't.

The bottleneck moved, and almost nobody followed it

The most useful idea in the 2026 "loop engineering" discourse is this:

In any agent loop, the verifier is the bottleneck. Not the model.

Generation is cheap and spins forever. The loop produces value only as fast as something can judge ship it, retry, or stop. Andrew Ng talks about evaluators. Karpathy frames the whole craft as generation and verification. The practitioners writing about loop engineering all land on the same gate.

Now multiply that by composition.

One agent, one loop, one verifier. Hard, but understood. N agents across M protocols inside a single goal? The verification surface explodes. Which step failed? Was the output even structured? Did the right agent get called? Was it allowed to do that? Single agent loop tools don't answer these questions, because they were never asked to.

Chat output makes it worse

Even when a multi agent run works, the result arrives as prose.

A chat bubble can't be checked against a schema. It can't be diffed between runs. It can't be monitored. It evaporates the moment you scroll. If the verifier is the bottleneck, then output you can't verify is output you can't trust. Prose is the least verifiable format our industry has ever shipped at scale.

Structured output is not a UX preference. It is a precondition for verification.

So what would the missing layer look like?

Sit with the problem long enough and a spec starts writing itself. MCP and A2A standardize how a message gets from A to B. They say nothing about how a dozen independently running agents get planned into one goal, called in the right order, authenticated, verified, and rendered. That missing layer is an agent harness. Here is what it would need:

  1. Protocol agnostic dispatch. MCP and A2A today, n8n or OpenAPI or LangGraph servers tomorrow, through thin bridges that inherit auth, retries, and payments instead of rebuilding them per protocol. MCP and A2A should be just the first two bridges.
  2. Discovery treated as retrieval. Not "stuff every agent into the context window and pray." Search. Filter, rank, inject only the relevant agents as tools, only when this turn needs them.
  3. Verification as pipeline policy, with receipts. Structural checks today, semantic judging tomorrow, always explicit about which one you are getting. Every step gets a verdict, and a finished run should be exportable as evidence, not just a transcript you have to trust.
  4. Structured output contracts. Dashboards, not chat bubbles. Output that persists, and output you can check.
  5. Identity and scope as contract. Agents that declare what they are allowed to do, in a versioned spec that can't break underneath the people building on it.

Nothing on this list is a model problem. It is orchestration, observability, and contract design.

The question

The protocols standardized in eighteen months. The composition layer is roughly where MCP was in late 2024: everyone needs it, nobody has named it, and the glue code piles up.

So I will ask you what I have been asking myself:

What would you put in the harness layer? What is the property I am missing that would make multi protocol agent runs trustworthy in production? And what is on my list that you think is wrong?

I have been building one answer for a while. More on that this week.

Sources and further reading:

Top comments (0)