Someone forwarded me a LinkedIn carousel this morning, Thursday, October 2nd. Bold block letters: “Understanding AI Agent Architecture — The Backbone of Intelligent Systems.” Three layers, stacked like a wedding cake. Infrastructure on the bottom, “Agentic” in the middle, Application on top. Four protocol acronyms in a row — MCP, A2A, ACP, ANP — presented like four flavors of the same thing. A question at the end asking how multi-agent systems will transform enterprise automation in the next three years.
The shape isn’t wrong. Compute underneath, orchestration in the middle, product on top — that’s a real way to draw this. What’s missing is every fact that would make it useful. “Cloud Platforms (Azure, AWS, GCP)” isn’t an architecture, it’s a logo lineup. Four protocols listed side by side implies four live options. One of them is already dead.
What’s actually running under the infrastructure layer
Three products, three names, three real dates. AWS Bedrock AgentCore went to general availability on October 13, 2025, after a preview that started that July — it bundles a Runtime, a Gateway for exposing tools, an Identity service, Memory, Observability, and a sandboxed Code Interpreter, and Amazon added A2A support to it in November. Azure AI Foundry Agent Service hit GA on May 19, 2025 at Build, then got folded into the renamed Microsoft Foundry this past January. Google’s version is split in two: Vertex AI Agent Builder, previewed at Cloud Next ‘24, for the managed/no-code path, and the Agent Development Kit, open-sourced under Apache 2.0 on April 9, 2025, for people who want to write Python or Java and own the orchestration loop themselves.
None of that is a logo. It’s three different bets on how much control you give up in exchange for not running your own queueing, retry, and tool-execution sandbox. Worth knowing which bet you’re making before you pick one.
Two real protocols, one casualty, one wildcard
MCP — the Model Context Protocol — is Anthropic’s, announced November 25, 2024. It’s a JSON-RPC client-server spec: an LLM-side client talks to a server that exposes tools, resources, and prompts in a shape the model can call. It’s the one that actually spread. VS Code shipped it GA in July 2025, Cursor’s had it since version 1.0 that June, and it’s live in OpenAI’s own Responses API. On December 9, 2025, Anthropic handed it to the Linux Foundation’s new Agentic AI Foundation, co-founded with Block and, notably, OpenAI — with Google, Microsoft, AWS, Cloudflare, and Bloomberg joining as members. A protocol that OpenAI and Google both sit on the governance board for is not a vendor toy anymore.
A2A — Agent2Agent — is Google’s, from April 9, 2025. It’s billed as peer-to-peer, but reading the actual spec, it’s closer to client-agent-to-remote-agent: one side publishes an Agent Card at a /.well-known/agent-card.json path, the other side reads it and hands off a task. Less symmetric than the name suggests, still genuinely useful for the thing it does, which is letting one agent delegate work to another agent it doesn’t control. Linux Foundation again, June 23, 2025, with AWS, Cisco, Salesforce, SAP, Microsoft, and ServiceNow as founding members.
Those two are now converging — most of the infrastructure products above ship both.
Then there’s ACP. IBM Research shipped one in early-to-mid 2025 as a REST-based complement to MCP. It lasted a few months. On August 25, 2025, it merged into A2A, and the GitHub repo — a little over a thousand stars at the time — is archived now. If you want a one-line argument for why standards consolidation matters more than feature lists in this space, that’s it: a real protocol from a serious lab, dead in under a year, because the market didn’t need three ways to do agent handoff.
ANP — Agent Network Protocol — is real code, roughly 1,400 GitHub stars, built around decentralized identity (did:wba) for agent discovery. No consortium behind it, one small maintainer group, and independent write-ups describing it as having “weak international influence” next to A2A. It might go somewhere. It hasn’t yet. Listing it next to MCP and A2A on a slide implies parity that doesn’t exist today.
(FIPA’s Agent Communication Language, from 2002, is a different ACP-shaped acronym some people confuse with IBM’s. It’s a pre-LLM speech-act spec still maintained by an IEEE working group. Interesting history, irrelevant to anything you’d build this year.)
The middle layer is where the actual argument is happening
“Agent A does task processing, Agent B does automation, Agent C does orchestration” is a diagram, not a decision. Here’s what people are actually choosing between, as of this month.
LangGraph hit 1.0 in October 2025 and has the case study to back it up: Replit uses it in production, documented on LangChain’s own customer page. CrewAI also went GA in October 2025 and has a PwC case study circulating — but it’s vendor-published, not independently reported, so hold it a little looser. Microsoft’s AutoGen went into maintenance mode in October 2025, replaced on Microsoft’s own roadmap by the new Agent Framework; the original AutoGen team split off and kept building the open-source line as AG2. OpenAI shipped an Agents SDK in March 2025 — I went looking for a named, independently-verified production deployment of it and came up empty, which doesn’t mean none exists, just that nobody’s written it up yet. Anthropic’s Claude Agent SDK, renamed from the Claude Code SDK on September 29, 2025, has the strongest case study of the five: Spotify built an internal tool called Honk on it, and both Spotify’s own engineering blog and Anthropic’s customer page independently describe the same number — more than 650 agent-generated pull requests a month.
If I had to bet on which of these to learn first based on who’s actually shipped something with it and let you read the receipts, it’s LangGraph or Claude Agent SDK. Not because the others are bad — because the other three are currently backed by a vendor’s self-reported number, a maintenance-mode notice, or silence.
What this looks like built, with real numbers attached
Anthropic published the clearest from-the-ground-up account I’ve found of what the middle box actually contains once you stop drawing it as a circle: “How we built our multi-agent research system”. A lead Opus 4 agent reads the query, breaks it into subtasks, and spins up Sonnet 4 subagents in parallel — each with its own isolated context window, an explicit objective, a required output format, and specific tool guidance so it doesn’t wander. Tools get exposed through MCP. Subagents write their intermediate findings out to external memory before they hit the roughly 200K-token ceiling on their own context, and a separate CitationAgent handles sourcing at the end so citation logic doesn’t compete with research logic for the same context budget.
The numbers they published: +90.2% over a single-agent baseline on their internal eval, roughly 15x the token cost of a single chat conversation, and up to 90% less wall-clock time on research tasks where the work actually parallelizes. That last tradeoff is the whole design in one sentence — you’re spending 15x the tokens to buy back 90% of the time, and that trade only makes sense when a human is sitting there waiting on the answer.
The part no infographic includes: it doesn’t always work
Klarna’s OpenAI-powered support assistant is the application-layer case study everyone cites — 2.3 million conversations a month, framed by OpenAI’s own February 2024 write-up as doing the work of roughly 700 full-time agents. What gets left off the slide: Klarna’s CEO told Bloomberg and Reuters in May 2025 that support quality had slipped, and the company went back to hiring humans. Same system, same company, fourteen months apart, two completely different stories — and the infographic version only ever quotes the first one.
That’s not an argument against building this. It’s an argument against believing anyone’s deployment number, including the ones in this post, until you’ve seen what it looks like a year later.
Where this series goes next
This post is the map. The next one is me actually wiring a small agent through MCP with a real orchestrator — probably LangGraph, since it’s the one with a production case study I can point at — and publishing what breaks, with the code. Not a redrawn diagram. A repo.