Mapping Agentic AI Protocols to the OSI Stack: What Fits, What Doesn't

In 1984, ISO published the OSI Reference Model. Seven layers, clean diagram, still on every networking whiteboard forty years later. But OSI never shipped a single production packet. TCP/IP was already running the internet by the time OSI showed up. TCP/IP won the deployment race. OSI ended up winning something else: the vocabulary everyone still uses to talk about networks, including networks that don't run OSI at all. Agentic AI looks like it's heading into a similar split, though it's too early to say how it lands. MCP, A2A, ACP, AG-UI, ANP are already in production. Teams are wiring these together right now to let agents reach tools, reach each other, and reach people. What's missing is a shared layered model for how all of this fits together, the kind of model networking eventually got from OSI. This piece tries to build one: take the OSI stack, place agent protocols against it layer by layer, and see what actually lines up. More of it lines up than I expected going in. The parts that don't are the interesting bit. The protocols MCP comes from Anthropic and is now under open governance. It gives a model a standard way to reach outside tools and data — a database, a file system, an API — instead of every application writing its own bespoke integration. Google built A2A for a different problem: getting one agent to find another agent, hand it a task, and collect the result. Agents publish "Agent Cards," JSON files describing what they do and where to reach them, so other agents can use them without hand-rolled integration work. ACP started inside IBM's BeeAI project and now sits under the Linux Foundation. It aims at roughly the same goal as A2A but keeps things closer to plain REST over HTTP. Less structure, easier to bolt onto whatever web infrastructure a team already has. AG-UI is the odd one out here because it isn't agent-to-agent at all — it's agent-to-human. It streams events (text as it's generated, tool calls as they start, state updates) to a live interface, so a person watches the agent work in real time and can jump in, instead of waiting for one final answer. ANP takes the most decentralized approach of the group. Agents identify themselves with DIDs, publish descriptions of what they can do, and work out the details of how they'll talk to each other on the fly, without needing a central registry to check in with. None of these protocols are really competing with each other, even though a lot of the writing about them frames it that way. Nobody asks whether Ethernet beats TCP — they're not solving the same problem. The OSI model, for anyone who's forgotten Each layer only has to know about its own job. Layer 1 doesn't care what's inside the bits it pushes down a wire. Layer 7 doesn't care whether it's running over fiber or Wi-Fi. That separation of concerns is the entire reason the model held up as long as it has, and it's the thing to watch as we swap agents in for routers. The mapping Nothing agent-specific happens at layer 1. It's just GPUs and inference servers, borrowed straight from existing cloud infrastructure. No protocol touches it directly. Layer 2 is where agent protocols quietly reuse the existing web instead of inventing new wire formats. A2A runs over HTTP and JSON-RPC. AG-UI runs over WebSockets or Server-Sent Events. Nobody built a new transport for agents. They picked from what was already lying around, which is the right call this early in the game. Addressing and discovery sit at layer 3, and the mapping holds up well here. A2A's Agent Cards function like a lightweight DNS for agents: a JSON file at a known URL saying what an agent can do and how to reach it. ANP pushes further, giving each agent a decentralized identifier that isn't tied to any one server or company. Layer 4 handles reliable delivery and connection state in classic networking. For agents, the closest equivalent is task lifecycle tracking. A2A defines explicit states — submitted, working, completed, failed, input-required — so a calling agent always knows where a task stands. It's a similar idea to how TCP tracks whether a connection is open, closing, or dead, just applied to units of work instead of packets. Things stop resembling networking around layer 5. ANP includes a "meta-protocol" step where two agents negotiate, in natural language, how they're going to communicate for a given exchange. Routers don't do this — two routers have never once sat down and discussed, in English, what format they'd prefer. This is one of the few places where agentic AI isn't borrowing an old pattern at all. Presentation, layer 6, covers formatting and translation in classic networking. The agent version is content and modality standardization — MCP's schemas for describing tools and resources, or ACP leaning on MIME types so an agent can pass around text, images, or audio without changing the protocol itself. Same underlying job either way: get both sides to agree on the shape of the data before either one tries to interpret it. Most of what people actually argue about lives at layer 7. A2A and ACP handle agent-to-agent orchestration. AG-UI handles agent-to-human interaction. This is also where the confusion in a lot of comparison articles comes from — A2A and ACP solve a machine-to-machine problem, AG-UI solves a machine-to-human problem, and lumping all three into one "agent protocols" bucket obscures that they're not even trying to do the same thing. Where it breaks The table above covers the parts that translate. Three things agentic AI needs have no real home in OSI, because OSI was built for a world of trusted, human-operated machines. Identity is the clearest gap. OSI doesn't have a layer for proving who you are to something you've never talked to before — it mostly assumes the network is trustworthy, or pushes the question up to the application layer as an afterthought. An agent talking to a stranger agent has no shared history to fall back on, so identity has to be built in rather than bolted on later. ANP handles this with DIDs and digital signatures rather than treating identity as optional. Payment is a newer problem, and a stranger one. OSI's authors weren't thinking about machines paying each other, because in 1984 that wasn't something computers did. It's a live requirement now — an agent might need to pay another one before it'll respond to anything. A few current proposals reuse HTTP's existing status codes for this: 401 already means "you're not authenticated," so the thinking goes, why not treat 402 (Payment Required) the same way, as a trigger for a settlement step. There's no equivalent anywhere in OSI's seven layers. Governance is the messiest of the three, and the one with the least progress. If an agent misrepresents what it can do in its Agent Card, or takes an action nobody signed off on, who answers for it? OSI never had to answer this because a human operator was always assumed to be on the hook, not the machine. That assumption stops working the moment agents start making their own decisions. These aren't minor gaps you can patch later. Whether agentic AI protocols converge the way TCP/IP eventually did, or splinter the way early networking almost did before TCP/IP won, probably depends on how these three get resolved. Where it's still unsettled Even inside the layers that do map cleanly, some of it hasn't settled yet. Payments are a good example: there's more than one approach competing for that same layer, with different assumptions about settlement and compliance. OSI ran into something similar with transport — it specified exactly one transport layer, and the actual internet built two anyway, TCP for reliability and UDP for speed, because a single abstract layer couldn't cover every real use case. Expect the same kind of fork here. Some of these layers will merge over time. Some protocols sitting at the same layer today won't both make it. TCP/IP or OSI? Is agentic AI heading toward a TCP/IP moment, something ships and wins by adoption, or an OSI moment, where a model becomes the shared vocabulary even though no implementation ever matches it exactly? It looks like both are happening, just at different layers. MCP is playing the TCP/IP role. It shipped, people adopted it, and it's becoming a default without much resistance. Identity, payment, and governance are still stuck at the OSI stage: plenty of proposals, not much production traffic. Networking went through this same split the first time around. There's no obvious reason agentic AI gets to skip it. \