Part III of 5 · Chapters 16 to 20
The vendors' catalogue, read as settings of the levers
Patterns, frameworks and standards read as settings of the eight levers, with the disagreements that divide the field and the state of the evidence.
Chapters (5)
16. Patterns and frameworks are lever settings under different names17. Two protocols have settled: MCP toward tools, A2A between agents18. The method behind this report holds by convention, not by mechanism19. Practitioners disagree on three points, and practice has begun to answer20. The field claims much and measures little: eleven claims, sorted16. Patterns and frameworks are lever settings under different names
Part II built eight levers and showed that they separate real systems. Part III uses them. Can the patterns and frameworks that vendors publish be read as settings of those eight dials? This chapter shows that they can, and the reading has a practical benefit. Two products that share a word often turn out to set different dials, and two that use different words often set the same one.
The first obstacle is the number of terms. A practitioner meets loop, scaffold, harness, framework, pattern and orchestrator in the same week, with no rule for how they relate. They can be put in order by asking one question of each: how close is it to the first principle, the bare loop of chapter 5, and how close to the levers that configure that loop? Figure 16.1 draws the result in three tiers, with the bare loop at the base.
Two terms sit next to the loop itself.
- Loop engineering is the writing of the cycle of tool use, planning and reflection (The Batch 241). It decides how one model call handles the feedback from the previous one.
- Scaffold, as chapter 3 defined it, is the code around the model that parses its output, runs the tool it asked for, and formats the result (Inside the Scaffold, arXiv 2604.03515).
Four terms name what configures the levers.
- Agentic context is what is assembled for the model at each decision: instructions, history, retrieved material. It is the Context lever in practice.
- Harness is the runtime around the scaffold, with its sandbox, its error recovery, its checks and its gates (OpenAI Agents SDK). It carries the Action capability, Verification and Human control levers.
- Specification and protocol are the agreed formats at the boundaries of a system, such as the Model Context Protocol (MCP Specification) and Agent2Agent (A2A Specification). The next chapter is devoted to them.
- Framework is a library that bundles scaffold, harness and state handling behind one interface, such as LangGraph, Microsoft Agent Framework or Google ADK. It offers all eight levers ready-made, and hides part of how each is set.
Three terms name arrangements built from the rest.
- Agentic pattern is a named way of combining several model calls, such as chaining or routing (Building Effective Agents).
- Orchestrator is whatever plans a task, hands out its pieces and gathers the results, whether it is a model or a program.
- Topology is the shape of a whole deployment: several agents, their harnesses, and the humans who oversee them.
Figure 16.1: The nine terms of this chapter in three tiers, drawn by this report, with the terms nearest the loop at the bottom.
None of these layers changes the loop underneath. They are ways of packaging decisions about it, and the vendors’ catalogues can be read with that in mind.
Anthropic sorts its catalogue with the line drawn in chapter 2, workflows on one side and agents on the other (Building Effective Agents). Its workflows, which are prompt chaining, routing and parallelization, set the Control loop lever to code and write the cut of the Decomposition lever in advance. Its orchestrator-workers pattern moves one dial: a model now decides the cut at run time. Its evaluator-optimizer pattern sets the Verification lever, with one call judging the output of another in a loop. The same document warns against heavy frameworks. In its authors’ experience, the systems that work in production keep the code around the model simple.
OpenAI starts from a different question, whether orchestration goes through the model or through code (OpenAI Agents SDK). That is the Control loop lever under another name. Within its SDK, two arrangements set the Decomposition lever in opposite ways. With agents used as tools, a manager keeps the conversation and calls specialists for bounded subtasks. With a handoff, the specialist takes over the conversation, and control and context move with it.
Framework vendors package those choices. Microsoft Agent Framework merges Semantic Kernel and AutoGen into one SDK (Microsoft Agent Framework). Its graph engine fixes the Control loop lever in code, its checkpointing sets the State persistence lever, its pause and resume serve the Human control lever, and its group patterns set the Decomposition lever. CrewAI pairs teams of agents defined by role with flows driven by events. Google publishes a catalogue of agent design patterns (Google Cloud Architecture), and its Agent Development Kit, met in chapter 8, lets a workflow agent run a sequence without consulting a model.
Reading the catalogues this way exposes a trap in the vocabulary. The same word covers different settings. An orchestrator at Anthropic is a model that breaks down a task nobody planned. The manager in OpenAI’s SDK calls a fixed set of specialists and keeps the conversation: what defines it is who answers the user, not who decides the cut. Routing at Anthropic picks a specialized prompt and transfers nothing. A handoff at OpenAI transfers the whole conversation. Someone who compares two products by their labels compares nothing.
Table 16.1 therefore sets the labels aside and records, for each pattern or framework, the dials it sets.
Table 16.1 Patterns and frameworks read as lever settings
| Pattern or framework | Control loop | Decomposition and specialization | Other levers it sets explicitly |
|---|---|---|---|
| Anthropic: chaining, routing, parallelization | Code decides | Cut written in advance, by step, by role or by instance | None |
| Anthropic: orchestrator-workers | A model decides the cut | Subtasks defined at run time | None |
| Anthropic: evaluator-optimizer | A loop between two calls | One call produces, one judges | Verification |
| OpenAI: agents as tools | The manager decides | Specialists handle bounded subtasks | Context stays with the manager |
| OpenAI: handoffs | The specialist takes over | The cut follows the routing | Context moves with control |
| Microsoft Agent Framework | A graph, in code | Group patterns for several agents | State persistence, Human control |
| CrewAI | Flows driven by events, in code | Teams of agents defined by role | State passed along the flow |
| Google ADK: workflow agents | Sequence fixed without consulting a model | Sequential, parallel or loop | State persistence |
Every row is a trade, and its currency is the one this report keeps meeting. A pattern does not make the model reason better. Chaining buys accuracy per step and pays in latency. Several agents buy specialization and pay in tokens. Figure 16.2 sets those two trades side by side.
Figure 16.2: The two trades named in the text, drawn by this report. The first trade is stated in Anthropic’s Building Effective Agents, and the token cost of several agents in its account of a multi-agent research system. No measured comparison lies behind the figure.
The reserve is the same for every row of the table. No vendor publishes a measurement that compares its patterns with one another on cost, latency or success. The catalogues are presented as good practice drawn from work with customers. They are design positions, and the figure above is this report’s reading of them.
Table 16.1 shows what the settings are. It does not show how two systems built by different teams can connect at all, which depends on the agreed formats at their boundaries.
17. Two protocols have settled: MCP toward tools, A2A between agents
Frameworks are what a team builds with. Protocols are what lets one team’s agent work with another’s tools, or with another agent. This chapter asks which of those protocols are real standards today. The picture that circulates, of several rival standards fighting for the same ground, is out of date. Two protocols have settled on two different boundaries, and both now sit under the same neutral foundation.
A protocol, in this context, is an agreed format for messages between two pieces of software, so that either side can be replaced without rewriting the other. Agentic systems have several boundaries where such an agreement is useful, and Figure 17.1 lays them out: between an editor and a coding agent, between an agent and its tools, between one agent and another, and between an agent and the registry where it can be found.
Figure 17.1: Four boundaries of an agentic system and the standard that sits on each, drawn by this report from Table 17.1. The sources are the specifications of the Agent Client Protocol, the Model Context Protocol, Agent2Agent and OASF. The two settled protocols are filled in, and no boundary depends on another.
Between an agent and its tools: the Model Context Protocol
The Model Context Protocol, or MCP, standardizes how an application built on a language model connects to tools and data sources. Anthropic created it. It exchanges messages in JSON-RPC 2.0, a common format for calling a remote procedure, and takes some inspiration from the Language Server Protocol that code editors use to talk to programming-language tooling (MCP specification).
The protocol names three parties. A host is the application the user works in. A client is the connector inside that application. A server is the service that offers capabilities. A server can offer three things: resources, which are data to read, prompts, which are prepared templates, and tools, which are functions the model can call.
The protocol changed shape in 2026. The revision dated 2026-07-28 replaced the one dated 2025-11-25 as the current version (MCP versioning). Its main change is that MCP became stateless at the protocol layer. The session header that tied a client to one server instance was removed, so requests can be routed to any instance without a shared session store (MCP Blog). The same revision lets a server ship an interactive HTML interface that the host displays in an isolated frame, tightens authorization, and introduces a formal deprecation policy with at least twelve months between deprecation and removal. Three older features were deprecated under that policy: roots, sampling and logging.
Governance changed as well. In December 2025 Anthropic donated MCP to the Agentic AI Foundation, a fund hosted by the Linux Foundation (Anthropic). The figures published at the time were more than 10,000 published MCP servers (Linux Foundation) and more than 97 million monthly downloads of its Python and TypeScript libraries, the second figure coming from Anthropic.
Between one agent and another: Agent2Agent
MCP stops at the edge of one agent. When two agents built by different organizations have to cooperate, each is opaque to the other, and a different agreement is needed. Agent2Agent, or A2A, is that agreement. Google developed it, version 1.0.0 was released in March 2026, and version 1.0.1 followed in May (A2A releases).
A2A covers three needs. The first is discovery: an agent publishes an Agent Card, a document describing what it can do, at a predictable web address (A2A specification). Since version 1.0 a card can be cryptographically signed, so that a partner can verify who it is dealing with before exchanging anything (announcement v1.0). The second is the unit of work. A2A models a task as an object that passes through eight defined states, among them submitted, working, input required and completed. The third is transport, and the specification supports three.
A2A is also under neutral governance. The Linux Foundation formed the Agent2Agent project in June 2025 with Amazon Web Services, Cisco, Google, Microsoft, Salesforce, SAP and ServiceNow (Google Developers Blog). By April 2026 it counted more than 150 supporting organizations (Linux Foundation).
The rival that merged, and an acronym with four meanings
Many accounts still describe a three-way contest between MCP, A2A and IBM’s Agent Communication Protocol. The contest ended in August 2025. IBM’s team announced that it was winding down active development and would contribute its technology to A2A, and IBM took a seat on the A2A technical steering committee (i-am-bee).
Part of the confusion comes from the letters. “ACP” has stood for four different things. The first is IBM’s retired protocol. The others are an Agent Connect Protocol from Cisco whose repository is now archived (agntcy/acp-spec), the Agent Client Protocol that connects a code editor to a coding agent (Agent Client Protocol), and OpenAI’s Agentic Commerce Protocol for purchases (OpenAI). A reader who meets “ACP versus A2A” has to ask which ACP is meant, and for three of the four the comparison makes no sense.
Two layers, with two caveats
What remains is usually presented as a doctrine of two layers. MCP manages the integration of tools inside an agent, and A2A handles coordination between agents (A2A and MCP). Google states the division explicitly (Google Open Source Blog).
Two caveats apply. The doctrine is stated from one side. The A2A documentation explains how it fits with MCP, while the overview of the MCP specification does not mention A2A at all. And the consolidation was no single event. The transfers to the Linux Foundation took place between June and December 2025, in separate projects. What they have in common is the outcome: competing vendors now sit on the same steering committees.
Table 17.1 places the protocols and conventions on the boundaries they actually cover.
Table 17.1 Agentic standards and the boundary each one covers
| Standard | What it connects | Message format | Steward | Published adoption figure |
|---|---|---|---|---|
| Model Context Protocol (MCP) | An agent application and its tool servers | JSON-RPC 2.0, stateless since the 2026-07-28 revision | Agentic AI Foundation (Linux Foundation) | More than 10,000 published servers; 97M+ monthly library downloads (Anthropic) |
| Agent2Agent (A2A) | Two agents that are opaque to each other | JSON-RPC, gRPC or HTTP with JSON | Linux Foundation project | More than 150 supporting organizations (Linux Foundation) |
| Agent Client Protocol | A code editor and a coding agent | JSON-RPC over standard input and output locally; HTTP or WebSocket remotely | Open project created by Zed | None published (Agent Client Protocol) |
| Agent Communication Protocol (IBM) | Agents, over REST | Retired | Merged into A2A in August 2025 | Not applicable (i-am-bee) |
| Open Agentic Schema Framework (OASF) | An agent and the registries that describe it | Attribute-based records | AGNTCY project (Linux Foundation) | More than 65 supporting companies for AGNTCY as a whole (LF AGNTCY) |
| AGENTS.md | A repository and the coding agents that read it | A Markdown file at an agreed location | Agentic AI Foundation (Linux Foundation) | More than 60,000 open-source projects (agents.md) |
Two entries in the table are lighter than a protocol. OASF belongs to AGNTCY, a project first open-sourced by Cisco in March 2025. It defines a common schema for describing agents, modelled on a schema used in cybersecurity (OASF). AGENTS.md is a convention, not a protocol: a file in a known place where a project tells coding agents how to work in it. Identity is less advanced than either. The proposal read for this report was an early draft at the Internet Engineering Task Force that adapts existing authorization standards to agents, and that draft has since expired (IETF draft).
The reserve on this chapter concerns its adoption figures. They are published by the stewards of the protocols themselves, at dates that differ, and nothing allows them to be audited. A count of published servers says how many exist, not how many are used. And no measurement read here says what these protocols cost in latency when a request crosses several agents.
For a designer the reading is simple. A protocol is chosen by the boundary it sits on, whoever its original author was. Tools are connected through MCP, and agents that belong to someone else are reached through A2A. Writing a private protocol for either boundary means maintaining alone what the rest of the field now maintains in common.
Standards fix the interfaces and leave the method open. The next chapter turns to one method in particular, the one this report was produced with, and judges it on the eight levers.
18. The method behind this report holds by convention, not by mechanism
One method in this catalogue cannot be described from the outside, because it is the one that produced this report. The 3-layer Directive / Orchestration / Execution method is the working arrangement of the environment in which these chapters were researched and written. Leaving it out would be convenient. Putting it through the same eight levers is the more useful test, and the only fair way to do it is to judge it as severely as the others.
The method splits the work into three layers. Directives are instructions written in natural language, one per role, that say what to do. Orchestration is a language model that reads the directives, routes the work, and holds the points where a human must approve. Execution is ordinary Python scripts for whatever can be done without judgement. The stated reason is that errors compound, so anything mechanical is pushed into code.
Figure 18.1: The three layers of the method, drawn by this report, with the four approval points on the orchestration layer. The idea that a harness can be written in natural language is the one studied in arXiv 2603.25723.
The rules quoted below are taken word for word from the instruction file of that environment. Each lever gets the same two questions: what the setting buys, and what it leaves exposed.
Context (Lever 1)
Context is anchored in files rather than in the conversation. Each run has one specification file, and the rule about it is short:
“Every agent reads it before acting and updates it after.”
This is the just-in-time, curated context that chapter 6 recommends. The window is rebuilt from a small authoritative file, not from a growing transcript. The weakness is in the second half of the rule. The file is kept current by the same agents that depend on it, and nothing checks that they did. While this report was being written, the specification went on announcing 31 chapters for weeks after the plan had grown to 33. A source of truth that its readers maintain drifts in silence.
Action capability (Lever 2)
Actions are meant to pass through scripts, and the rule governs when a new one may be written:
“Check for tools first. Before writing a script, check
execution/. Only add one if none fit.”
Scripts are predictable and can be read before they run, which is a real gain over free-form commands. Chapter 7 asked for more than that. It separated what an agent is technically able to do from when it must ask, and it placed the guarantee in a perimeter enforced by the operating system. The method has no such perimeter. Its scripts are not sandboxed, and an orchestrator that can write a script can write one that does anything its user account can do. Containment here is a convention.
Control loop (Lever 3)
The loop is hybrid: code runs the mechanical steps, and a model decides what comes next. One rule bounds the model’s freedom to iterate:
“Every LLM critic (structurer, verifier) runs at most 2 passes against
report_rubric.md, then escalates to the user.”
Chapter 8 proposed a test for any system: at each decision point, is it a line of code or a model call that settles the matter? Applied here, the answer is a model call almost everywhere. The sequence of steps lives in a directive that the orchestrator reads and is expected to follow. The two-pass limit itself is an instruction to a model, and no counter enforces it. The method describes a deterministic pipeline and runs it on a probabilistic reader.
Decomposition and specialization (Lever 4)
The work is cut by step and by role, and the cut is written in advance by the human who designs the directives. The instruction file fixes the principle:
“Directives therefore name a role, never a model.”
This is the cheapest setting of the lever, a cut by step with no orchestrator inventing subtasks at run time, and it avoids the coordination overhead that chapter 9 documented. The price is rigidity, since a task that does not fit the planned sequence has nowhere to go. Nothing measures whether the chosen cut is a good one.
Verification and conformance (Lever 5)
Checks are divided by kind:
“Mechanical checks are deterministic.”
Heading levels, section balance and the presence of citations are checked by a script, and language models are kept for judging argument. That division follows chapter 10 closely, and it showed its limit in this very document. A check that a citation is present cannot check that the citation supports the sentence it follows. And the larger gap identified in chapter 10 applies in full. Nothing verifies that the orchestrator carried out the steps in the order the directive prescribes. The method checks its products and takes its process on trust.
State persistence (Lever 6)
State lives on disk, in plain files:
“It is what survives context limits and checkpoints.”
A run survives the end of a session or the loss of a context window, and a human can open the state and read it, which chapter 11 would count in its favor. What the method lacks is a schema. Resuming depends on a hand-over note that an agent writes at the end of a session, and the quality of the next session depends on the quality of that note.
Capability evolution (Lever 7)
The method learns by editing its own instructions, under a limit:
“On error: fix the script, test it, update the directive with what you learned.”
A second rule forbids creating or overwriting a directive without asking. Changes are therefore visible, versioned and approved, which is the governed form of evolution that chapter 12 argued for. The setting is also the slowest one available. Nothing is extracted from successful runs, and every improvement waits for a human.
Human control (Lever 8)
Four approval points are fixed in the pipeline:
“Never cross a gate without explicit user approval.”
Chapter 13 held that a gate is a control only when it is rare and informed. Four gates in a run that lasts days are rare, so the first condition is met. The second is weaker than it looks. Each gate shows the human a condensed view, and the system being supervised writes that view. The 93 % reflex approval measured by Anthropic concerned frequent prompts (Anthropic). Nothing shows that four gates escape the same reflex when each one arrives as a tidy summary at the end of a long session. The method records no approval rate of its own. As Gaube et al. warn, a supervisor can hold the responsibility without the means to exercise it (arXiv 2605.16278).
Verdict
Read across the eight levers, the method is a coherent low-cost setting. It uses curated context, a cut written in advance, mechanical checks in code, state on disk, governed evolution and rare gates, and each of those choices sits on the cautious side of its dial.
Its guarantees are of a different kind from the ones this report asked of others. Almost all of them are conventions that a model is asked to respect, where chapters 7 and 10 asked for mechanisms that hold whether or not the model cooperates. That is acceptable for the work it does. A research report is a low-risk product, every step is reversible, and a human reads the result. It would not be acceptable for an agent that moves money.
One paper lends the approach some support. Natural-Language Agent Harnesses, a 2026 study, asks whether the logic of a harness can be written as an editable natural-language document and executed by a shared runtime. Across coding, terminal and computer-use benchmarks, it reports task outcomes comparable to harnesses written in code (arXiv 2603.25723). That makes a directive-driven harness plausible. It does not validate this one, which the paper never tested, and which has never been measured against any alternative.
Figure 18.2: Three conventions of the method and the mechanism each would become, drawn by this report from the reading above and the extension sketched below. It shows a direction of extension, and none of the three mechanisms has been built.
Figure 18.2 sketches the direction in which the method would have to grow: tool servers behind a standard protocol, an enforced execution perimeter, and state with a schema. Each addition would replace a convention with a mechanism, and each would add to the bill. Part V asks when such a trade is justified. Before that, the next chapter looks at where practitioners themselves disagree about these settings.
19. Practitioners disagree on three points, and practice has begun to answer
The previous chapters of this part read the landscape as a set of lever settings. This one asks where practitioners actually disagree about those settings. Three disagreements keep returning: how to divide the work, how much framework to use, and where to put the intelligence. On each of them practice has started to speak, and on the first it has spoken clearly.
Figure 19.1: The three fault lines of this chapter, drawn by this report. On each line, the option on the right is the one current practice leans toward, on the evidence cited in this chapter, most of it from two companies describing their own products (Cognition, Anthropic).
One agent or several
The first disagreement sets a single agent against a team of agents working in parallel. The early multi-agent frameworks promised better results through collaboration. What they delivered, when several agents wrote at once, was conflict. Two agents editing the same code make incompatible decisions. Their styles clash, they handle the same edge case in opposite ways, and the result is fragile. The arrangement is also expensive. By Anthropic’s own count, a multi-agent system uses about 15 times more tokens than a chat exchange, where a single agent uses about four times more (Anthropic).
The clearest evidence on this line is a change of mind. Cognition, the company behind the coding agent Devin, first told developers not to build multi-agent systems at all (Cognition). Its warning was aimed at teams of agents that write in parallel, and it rested on two principles. The first was to “share context, and share full agent traces, not just individual messages”. The second was that “actions carry implicit decisions, and conflicting decisions carry bad results”. This is the dispute chapter 9 announced. A handoff assumes that context travels with control, and Cognition’s objection is that in practice it does not travel whole. Ten months later it revised its position, after watching which arrangements held up in production (Cognition).
What it now recommends is the single-writer principle. Several subagents may work at the same time, as long as they only read: they search the codebase, consult documentation, and gather what the task needs. Every change to the state of the work passes through one agent, which writes alone. Most multi-agent deployments that work, Cognition observes, are of this read-only kind. They behave less like a team of colleagues and more like several tool calls made at once.
Figure 19.2: The single-writer principle, drawn by this report from the arrangement Cognition recommends (Cognition). Several subagents read at the same time, and every change to the state of the work passes through one agent.
A framework or plain code
The second disagreement concerns how much ready-made structure to accept. A framework packages orchestration into graph structures and state containers that someone else designed. It gets a prototype running quickly. The complaint against it is opacity. The prompt that finally reaches the model is assembled out of sight, a failure is hard to trace, and the design is tied to the shape of the graph the framework allows.
The opposite camp writes the loop directly, with ordinary loops and conditions. Nothing is hidden, and the designer can see exactly what enters the context and what each step costs. One study pushes the idea further and writes the harness itself as a natural-language document. It reports task outcomes comparable to harnesses written in code (arXiv 2603.25723), with a specification that is shorter and easier to inspect. The previous chapter judged a method of that family.
In the model or around it
The third disagreement is about where the intelligence of a system should sit. One design puts a capable frontier model inside a simple loop and lets it plan. The other surrounds the model with elaborate rules, or places a smaller and cheaper model in charge of orchestration.
Two observations weigh on this choice. In Anthropic’s data, moving to a more capable model improved results more than doubling the token budget of the older one (Anthropic). And Cognition describes what goes wrong when a weaker model sits on top. A weaker model is poor at recognizing its own limits, so it fails at the one thing an orchestrator must do reliably, which is to know when to hand a problem upward (Cognition). Cognition calls this the reverse delegation problem.
Table 19.1 summarizes the three lines. The option in bold is the one current practice leans toward, on the evidence above, and most of that evidence comes from two companies describing their own products.
Table 19.1 The three fault lines and their trade-offs
| Architectural Fault Line | Option A (Structural / Heavy) | Option B (Functional / Native) | Economic Overhead | Primary Failure Mode |
|---|---|---|---|---|
| 1. Division of Labor | Parallel Writing Swarms | Single-Writer Architecture | ~15x Token Overhead (Anthropic) | Conflicting writes & code fragility |
| 2. Framework Abstraction | Black-box Framework DAGs | Native Code / Directive Harness | High debugging latency | Opaque prompts & locked state |
| 3. Intelligence Placement | Scaffold-Centric Orchestrators | Model-Centric Frontier Loops | High per-step routing cost | Reverse delegation bottleneck |
Read together, the three lines lean the same way. In each case the heavier structure lost ground to an arrangement that keeps control of state explicit and lets a capable model do the reasoning. That lean is a tendency reported by practitioners. Nobody has measured it, and the next chapter examines how much of what this field asserts has been measured at all.
20. The field claims much and measures little: eleven claims, sorted
Every chapter so far has carried a reserve about its evidence. This chapter gathers those reserves and asks the question directly: of what the field asserts about agentic methodologies, how much has been measured? Its verdict is that the field claims a great deal, measures little, and has published figures that do not hold.
The difficulty starts with who is speaking. Most of the available numbers come from the companies that sell the models and the frameworks. A vendor has every reason to show its architecture under favorable conditions, and none to publish what it costs or where it fails. A figure therefore has to be read with two questions in mind: who measured it, and under what conditions.
What tokens explain
The best-documented finding concerns spending. On BrowseComp, an evaluation of how well agents find hard-to-locate information on the web, Anthropic reports that token usage alone explains 80% of the variance in performance. Together with the number of tool calls and the choice of model, the share explained reaches 95% (Anthropic). The same source gives the cost of the architectures involved: about 4 times the tokens of a chat exchange for a single agent, and about 15 times for a multi-agent system.
Those two facts change how a performance gain should be read. If spending explains most of the result, then a system that scores higher while consuming fifteen times more has not shown that its structure helped. Much of what is reported as an architectural gain may be a larger budget.
What defenses withstand
Security is where published claims and measured reality are furthest apart. The papers that introduce a defense against prompt injection usually report attack success rates close to zero. Those rates are obtained against a fixed set of attacks, such as the test suite AgentDojo (arXiv 2406.13352). A real attacker does not stay fixed. They study the defense and adapt.
The Attacker Moves Second is a paper that tests exactly that (arXiv 2510.09023). Its authors took 12 published defenses and attacked each with methods that search for a way through. Every one of the 12 was bypassed, at success rates above 90%. A defense that reported near-zero failure had been measured against the wrong opponent.
The defenses that hold are of a different kind. CaMeL, described in chapter 7, does not try to detect a hostile instruction. It arranges the program so that content read from outside cannot change what will be executed (arXiv 2503.18813). The guarantee has a measured price: 77% of tasks completed, against 84% with no defense.
What cannot be attributed
The third finding is an absence. To know what an architecture contributes, one would compare two of them with the same model and the same budget. No such comparison exists in this corpus.
Public leaderboards do not fill the gap. An audit of submissions to SWE-bench, the most used benchmark for coding agents, examined 80 distinct approaches across its Lite and Verified versions (arXiv 2506.17208). The submissions rarely document their harness in detail. A reader cannot tell whether a higher score comes from the prompts, from the routing logic, or simply from a stronger model underneath.
Eleven claims, sorted
Table 20.1 applies this reading to eleven claims that circulate in marketing material and in secondary literature. Each is set against the primary source that confirms it, corrects it, or fails to support it.
Table 20.1 Eleven circulating claims and their status
| Claim / Metric | Reported Assertion | Empirical Status | Primary Source & Verified Correction |
|---|---|---|---|
| 1. MCP Server Ecosystem | 18,000 active MCP servers | Corrected | Over 10,000 published servers (Anthropic / AAIF) |
| 2. LangGraph Market Share | 43% enterprise adoption | Discarded | Unbacked promotional estimate; no primary methodology |
| 3. CoT Faithfulness | 41% faithful CoT reasoning | Corrected | The hint is mentioned 25% of the time by Claude 3.7 Sonnet and 39% by DeepSeek R1 (Anthropic) |
| 4. Context Rot Threshold | 20% to 45% drop past 64k tokens | Discarded | Continuous accuracy degradation slope; no 64k step threshold |
| 5. Multi-Agent Performance | +90.2% improvement over single-agent | Contextualized | Internal research eval on breadth-first queries (Anthropic) |
| 6. Multi-Agent Token Cost | 15x token consumption increase | Confirmed | Telemetry concession by multi-agent authors (Anthropic) |
| 7. Prompt Injection Defenses | Near 0% attack success rate | Refuted | >90% attack success rate under adaptive search (arXiv 2510.09023) |
| 8. Human Permission Gates | Effective execution control | Refuted | 93% reflex approval rate due to prompt fatigue (Anthropic) |
| 9. Process Conformance | Robust trajectory verification | Negative Result | No operational tool measures step-by-step process conformance (AgentEval) |
| 10. Agentic Conway’s Law | Direct organizational mirror | Discarded | Metaphorical analogy; unbacked by empirical software metrics (arXiv 2512.07665) |
| 11. Autonomous Execution | Unconstrained task completion | Qualified | The vendors’ own deployments bound autonomy with sandboxes, budgets and gates (Anthropic) |
Figure 20.1: The eleven claims of Table 20.1, counted by the status the table gives each one, drawn by this report. Each square is one claim and carries its number in the table. Only one claim is confirmed as stated, the token cost of multi-agent systems (Anthropic).
Three habits follow for anyone reading a claim in this field. Ask what was spent to obtain the result. Ask whether a defense was tested against an attacker who adapts. And ask whether two architectures were ever compared on equal terms, because so far they have not been.
This closes the reading of the catalogue. The settings exist, the vendors recommend them, and the evidence behind the recommendations is thin. One feature of those settings has been visible throughout and has not yet been examined: almost all of them are named after something people do at work. Part IV turns to that resemblance.
Sources cited on this page (40)
- A2A and MCP
- A2A releases
- A2A Specification
- Agent Client Protocol
- AgentEval, arXiv 2604.23581
- agents.md
- agntcy/acp-spec
- announcement v1.0
- Anthropic
- Anthropic / AAIF
- Anthropic, Building Effective Agents
- Anthropic, How we contain Claude
- Anthropic, multi-agent research system
- Anthropic, Reasoning models don't always say what they think
- arXiv 2406.13352
- arXiv 2506.17208
- arXiv 2512.07665
- arXiv 2603.25723
- arXiv 2605.16278
- CaMeL, arXiv 2503.18813
- Cognition: dont build multi agents
- Cognition: multi agents working
- Google Cloud Architecture
- Google Developers Blog
- Google Open Source Blog
- i-am-bee
- IETF draft
- Inside the Scaffold, arXiv 2604.03515
- LF AGNTCY
- Linux Foundation: a2a protocol surpasses 150 organizations lands in major cloud platforms and sees enterprise production use in first year
- Linux Foundation: linux foundation announces the formation of the agentic ai foundation
- MCP Blog
- MCP versioning
- Microsoft, Agent Framework 1.0
- Model Context Protocol
- OASF
- OpenAI
- OpenAI, Agents SDK
- The Attacker Moves Second, arXiv 2510.09023
- The Batch 241