The Agent Stack Is Standardizing in Real Time

There’s a plain-text file in this blog’s repository called AGENTS.md. It tells the AI agent that helps me publish how the project is laid out — where the content lives, how the pipeline runs, what to leave alone — and I add a line to it every time the agent gets something wrong. Nothing exotic: a README written for a machine instead of a person.

The strange part is that I didn’t invent its format. AGENTS.md is a standard now — the same file, in the same shape, sits in tens of thousands of other repositories, agreed on by a handful of companies that compete hard with each other, and it didn’t exist eighteen months ago.

That shouldn’t happen this fast, because standards almost always arrive late.

I’ve spent the last year and a half building on top of files and protocols like this one, and I want to write a series about them. This is the opening map — later posts go one layer deep on each: what a protocol actually says, what it gets right and wrong, what it’s like to build on. But first the landscape, and the question that got me started. Why is this happening so fast, and so early?

Standards usually come last

Think about how the foundations under us actually got laid.

The protocols that run the internet were standardized after a long, messy period of incompatible networks. SQL became a standard years after relational databases were in production. POSIX arrived to paper over a Unix landscape that had already fractured into a dozen dialects. USB replaced a graveyard of competing connectors that had been fighting it out on the back of every PC for years. In each case, standardization was the cleanup crew that arrived once the party was mostly over.

The pattern repeats because it’s rational. Standardizing early is expensive and risky: you might freeze the wrong design before anyone understands the problem, and you slow yourself down agreeing with rivals when you’d rather be shipping. So everyone builds their own thing, the market sorts out a few survivors, and then — once the shape of the problem is obvious and the cost of fragmentation has become unbearable — the industry reluctantly converges.

Build first. Fight. Standardize the winners. Late, every time.

In agents, they’re coming first

Here the order is inverted. The protocols are being written while the technology is still being invented — not over a decade but over months, not behind closed doors but in GitHub repos you can open right now, and (the part I still find hard to believe) by companies actively trying to put each other out of business.

Look at the dates:

November 2024 — Anthropic open-sources the Model Context Protocol (MCP), a standard way for agents to reach tools and data. The “USB-C for AI” framing sticks almost immediately.
April 2025 — Google announces A2A (Agent2Agent), a protocol for agents to discover and delegate to other agents. By June it’s donated to the Linux Foundation.
August 2025 — AGENTS.md emerges out of OpenAI and the broader tooling ecosystem: a plain-Markdown “README for agents” that tells a coding agent how your repo works. Zed ships its Agent Client Protocol the same month — an “LSP for coding agents” — and JetBrains joins shortly after.
September 2025 — Google publishes AP2 (Agent Payments Protocol) so agents can transact, built on W3C Verifiable Credentials and now heading to the FIDO Alliance.
December 2025 — Anthropic releases Agent Skills (the SKILL.md format) as an open standard. Days earlier, the Linux Foundation announces the Agentic AI Foundation (AAIF), a neutral home anchored by MCP, Block’s goose, and AGENTS.md.

And the one you may not have heard of, which is the most telling of all because of how niche it is: ATIF — the Agent Trajectory Interchange Format. It’s a JSON spec for logging the complete interaction history of an agent — every user message, internal reasoning step, tool call, and observation — so that the same recording can feed debugging, visualization, fine-tuning, and reinforcement learning. It comes out of the Harbor framework at the Laude Institute (the folks behind Terminal-Bench), and it’s still at the RFC stage. Think about that: the field is so eager to standardize that it’s writing a spec for the log format of agent session recordings before agents are even common in production. That’s not the cleanup crew. That’s people pouring the foundation while the building is still being designed.

The clearest signal isn’t any single protocol, though. It’s the AAIF itself. Its platinum members are AWS, Anthropic, Block, Bloomberg, Cloudflare, Google, Microsoft, and OpenAI — sitting at the same table to co-govern the plumbing. OpenAI adopted Anthropic’s MCP back in April 2025 and then built its Apps SDK on top of it. A major lab chose to build on a direct rival’s standard rather than fork its own. That basically never happens this early.

A map of what’s being standardized

It’s easy to drown in acronyms, so here’s how I keep them straight. Each one standardizes a different seam in an agent system:

Agent ↔ tools and data: MCP. How an agent reaches the outside world — files, APIs, databases.
Agent ↔ other agents: A2A and IBM/BeeAI’s Agent Communication Protocol (yes, also “ACP” — different thing). How agents discover, authenticate, and delegate to each other. There’s a small crowd here.
Editor ↔ agent: Zed’s Agent Client Protocol (the other “ACP”). How your IDE talks to whatever coding agent is driving it.
Packaging a capability: Agent Skills / SKILL.md. How you bundle instructions, scripts, and resources into something an agent can load on demand.
Instructions to the agent: AGENTS.md. The project-specific guidance an agent reads before it touches your repo.
The record of what the agent did: ATIF. The standardized trajectory — for debugging, evals, and training.
Money and identity: AP2 and adjacent work like Visa’s Trusted Agent Protocol. How an agent pays, and how anyone trusts that it’s allowed to.

Two quick notes that trip people up. First, “ACP” refers to two unrelated protocols — IBM’s Agent Communication Protocol (agent-to-agent) and Zed’s Agent Client Protocol (editor-to-agent). Same letters, different seam. Second, MCP and A2A are complementary, not competing: MCP connects an agent to its tools; A2A connects an agent to other agents. Most real systems will use both.

Why now? Why so fast?

So what broke the usual “standardize late” rule? A few things, I think.

The N×M problem shows up on day one. With agents, the integration explosion isn’t gradual — it’s immediate. Every agent wants every tool; every agent might need to talk to every other agent. Without a shared protocol you’re writing N×M bespoke connectors, and N and M are both exploding at once. A standard collapses that to N+M. In most technologies the pain of fragmentation accumulates slowly enough that you can defer the fix for years. In agents it’s acute from the first integration, so the incentive to standardize arrives early too.

The specs are tiny. This is underrated. AGENTS.md and SKILL.md are plain Markdown. MCP and the ACPs are JSON-RPC. These aren’t thousand-page telecom standards hammered out by a committee over a decade — they’re small, human-readable contracts you can adopt in an afternoon. Low adoption cost is why the curves move in months instead of years: AGENTS.md crossed 60,000 repositories, and MCP reportedly passed tens of millions of SDK downloads a month within its first year. When a standard is cheap to adopt, network effects do the rest.

Neutral foundations make coopetition survivable. The reason rivals can sit at one table is that nobody has to own the table. Donating a protocol to the Linux Foundation (or AP2 to FIDO) turns “Anthropic’s protocol” into “the industry’s protocol,” which makes everyone else willing to commit to it. This is a well-worn playbook — it’s how Kubernetes, PyTorch, and Node.js got their neutral homes, and how the W3C kept the web from splintering. The agent world reached for it remarkably quickly. The bet is that a bigger, shared pie beats a slightly larger slice of a fragmented one. So far that bet looks right.

And maybe the simplest reason: everyone watched the early internet grow up without these agreements and remembers the cost. The analogies people reach for — “USB-C for AI,” “the pre-standard internet,” “the LSP for agents” — aren’t decoration. They’re the industry saying we’ve seen this movie, let’s skip the fragmentation act this time.

Why I care, and why a series

This isn’t abstract spec-watching for me. That AGENTS.md file I opened with is just one of these standards I touch in a normal week. I wire up MCP servers. I package repeated work into Skills. When something breaks, I read back the agent’s transcript to find where it went wrong — exactly the kind of record ATIF is trying to make portable. When I wrote about making a site agent-friendly, that was the same instinct from the publishing side. None of this is something I study from a distance; it’s the substrate under nearly everything I’m building right now — and the unsettling, exciting part is that the substrate is being poured while I’m standing on it.

That’s exactly why it’s worth writing about carefully. We are watching a technical stack agree on its own grammar in real time, in public, before the dust has settled — which almost never happens, and which we’ll probably look back on as one of the more consequential things about this era. Most of these specs are young enough that the people building on them are also, in effect, helping decide what they become.

So this is the start of a series. From here I want to go one layer at a time — open up MCP and see what it actually says; pull apart the two ACPs; figure out what Skills get right that plain prompting doesn’t; and yes, dig into why a session-log format like ATIF might matter more than it sounds. Start with the map. Then zoom in.

Let’s find out what we’re standing on.