The Agent Stack Is Standardizing in Real Time

There is a plain-text file in this blog’s repository called AGENTS.md. It tells the AI agent assisting my publishing workflow how the project is organized: where content resides, how the build pipeline runs, and which files to leave untouched. Whenever the agent makes a misstep, I add another guideline to it. It is essentially a README written for a machine rather than a human.

What makes this remarkable is that I didn’t invent the convention. AGENTS.md is now an established standard. The exact same file structure sits in tens of thousands of repositories, agreed upon by fierce competitors, despite not existing eighteen months ago.

Historically, technology standards almost never arrive this early.

Having spent the past eighteen months building on top of these emerging protocols, I want to unpack them in a dedicated series. This article serves as the foundational overview. Later posts will analyze individual layers: the exact semantics of each protocol, their trade-offs, and what it feels like to build against them. But first, we need to examine the broader landscape and answer a curious question: why is standardization happening so fast, and so early?

Standards usually arrive last

Consider how earlier computing foundations were established:

The core protocols of the internet were codified only after a prolonged, painful period of incompatible networking implementations. SQL was standardized years after relational databases were running mission-critical workloads in production. POSIX appeared to unify a Unix ecosystem that had already fractured into conflicting dialects. USB replaced an unruly assortment of proprietary peripheral ports on the back of personal computers. In each historical case, standardization was the cleanup crew arriving after the chaotic phase had crested.

This sequence persisted because it is rational. Premature standardization is hazardous: you risk locking in flawed abstractions before anyone truly understands the problem domain, and negotiating with competitors slows down shipping. Consequently, everyone builds proprietary solutions, the market shakes out a few victors, and only then, when fragmentation costs become unbearable, does the industry reluctantly coalesce around a shared baseline.

Build first, compete aggressively, and standardize the survivors: that was the playbook for decades.

In the agent ecosystem, standards are coming first

With AI agents, the historical order has inverted. Protocols are being formalized while the underlying technology is actively being invented: across months rather than decades, in public GitHub repositories rather than behind closed standards bodies, and by companies that compete fiercely for market share.

Consider the recent timeline:

  • November 2024: Anthropic open-sources the Model Context Protocol (MCP), a standard contract for connecting agents to external tools and data sources. The “USB-C for AI” analogy catches on almost instantly.
  • April 2025: Google announces A2A (Agent2Agent), a protocol for autonomous agents to discover and delegate tasks to peer agents. By June, Google donates A2A to the Linux Foundation.
  • August 2025: AGENTS.md emerges from OpenAI and the broader developer ecosystem as a lightweight markdown manifest guiding repository-level agents. Zed announces its Agent Client Protocol the same month (an LSP equivalent for coding agents), with JetBrains quickly following suit.
  • September 2025: Google publishes AP2 (Agent Payments Protocol) for authenticated agent transactions, grounded in W3C Verifiable Credentials and later transitioned to the FIDO Alliance.
  • December 2025: Anthropic formalizes Agent Skills (SKILL.md) as an open specification. Days earlier, the Linux Foundation announces the Agentic AI Foundation (AAIF), creating a vendor-neutral home backed by MCP, Block’s Goose project, and AGENTS.md.

Another telling example is ATIF (the Agent Trajectory Interchange Format). ATIF defines a JSON schema for recording the complete execution trace of an agent: user prompts, internal reasoning tokens, tool invocations, and environment observations. The goal is to allow a single session trace to power debugging, visualization, regression evals, and reinforcement learning. Born out of the Harbor framework at the Laude Institute (the creators of Terminal-Bench), it is still an early RFC. The industry is standardizing session log schemas before multi-agent systems are even ubiquitous in production. That is not a late cleanup crew; that is laying municipal plumbing while the blueprints are still being sketched.

The strongest indicator of this shift is the AAIF itself. Its governing members include AWS, Anthropic, Block, Bloomberg, Cloudflare, Google, Microsoft, and OpenAI, all collaborating on foundational infrastructure. OpenAI adopted Anthropic’s MCP in April 2025 and constructed its Apps SDK on top of it. A major AI frontier lab chose to adopt its direct rival’s interface standard rather than fracturing the ecosystem with a proprietary fork. Historically, that level of early alignment is unprecedented.

Mapping the layers of standardization

To avoid getting lost in alphabet soup, it helps to understand that each specification addresses a distinct architectural boundary:

  • Agent to tools and data: MCP. Standardizes how an agent accesses external systems such as local files, REST endpoints, and database connections.
  • Agent to other agents: A2A and IBM/BeeAI’s Agent Communication Protocol. Standardizes how independent agents identify, authenticate, and coordinate tasks across networks.
  • Editor to agent: Zed’s Agent Client Protocol. Standardizes how code editors communicate with external coding agents driving the IDE.
  • Packaging capabilities: Agent Skills (SKILL.md). Standardizes how instructions, scripts, and context files are bundled for dynamic ingestion by an agent.
  • Repository guidelines: AGENTS.md. Provides repository-specific operational instructions that coding agents consume before modifying code.
  • Execution tracing: ATIF. Defines the interchange format for full agent trajectory logs across eval suites and training pipelines.
  • Identity and payments: AP2 and related efforts like Visa’s Trusted Agent Protocol. Establishes cryptographic proof that an agent is authorized to execute economic transactions.

Two points often cause confusion here. First, “ACP” refers to two completely separate specifications: IBM’s Agent Communication Protocol (agent-to-agent) and Zed’s Agent Client Protocol (editor-to-agent). They share an acronym but operate at different seams. Second, MCP and A2A are complementary rather than rival protocols: MCP connects an individual agent to its tools, whereas A2A connects one agent to another. Most production multi-agent architectures will utilize both.

Why is standardization happening so early?

What broke the traditional “standardize late” dynamic? Several factors stand out:

The combinatorial integration problem hits immediately. With agents, tool fragmentation does not scale gradually; it explodes on day one. Every agent framework wants access to every SaaS tool and database. Without a shared contract, teams must maintain N-by-M bespoke integrations, where both N and M are expanding simultaneously. An open standard collapses that burden to N-plus-M. In past technologies, fragmentation accumulated slowly enough that companies could postpone consolidation for years. In the agent space, the friction was intolerable from the outset.

The specifications are lightweight. AGENTS.md and SKILL.md are standard Markdown. MCP and ACP rely on standard JSON-RPC. These are not 800-page telecom committee documents negotiated over a decade; they are concise, human-readable contracts that a single engineer can implement in an afternoon. That low adoption friction explains why adoption curves move in months: AGENTS.md was adopted by tens of thousands of repositories in under a year, while MCP SDK downloads surged past millions monthly. When compliance is trivial, network effects take over rapidly.

Neutral governance enables coopetition. Competitors can sit at the same table because no single vendor controls the table. Donating protocols to the Linux Foundation or the FIDO Alliance transforms vendor initiatives into open public goods, giving rivals the confidence to adopt them without platform risk. This follows the successful playbooks of Kubernetes, PyTorch, and the web itself. The industry recognized early that expanding the shared ecosystem delivers more value than defending a fragmented silo.

Finally, the industry carries institutional memory. Having experienced the cost of the browser wars and proprietary mobile platforms, today’s leaders recognize the pain of fragmentation and chose to bypass that chapter entirely.

Why this series matters

This is not a theoretical exercise for me. The AGENTS.md file mentioned earlier is part of my everyday tooling. I regularly configure MCP servers, bundle reusable automation into Skills, and inspect execution transcripts when an agent veers off course. This open substrate underpins virtually everything I build today, and watching that foundation solidify in real time is both disorienting and exciting.

We are witnessing an entire technical stack settle on its foundational grammar in public, before the dust has settled. Because these specifications are young, the practitioners building against them today are actively shaping what they will become.

This post opens a deeper series. In upcoming articles, we will explore the specifics of each layer: analyzing what MCP does under the hood, comparing the two ACP protocols, examining where Skills outperform raw prompt engineering, and exploring why trajectory schemas like ATIF matter for production reliability.