AGENTS.md, MCP, and A2A: The Three Standards Every Agent Team Needs

The fragmentation problem

Six months ago, every AI tool had its own convention for agent configuration: .cursorrules, .windsurfrules, .clauderules. Every framework had its own tool-calling format. Every orchestrator had its own agent communication protocol.

That era is over. Three standards have emerged, each solving a different layer of the agent stack. They're now governed by the Linux Foundation's Agentic AI Foundation (AAIF), which means they're vendor-neutral and here to stay.

The three layers

Think of it as a stack:

┌─────────────────────────────────┐
│  AGENTS.md — Interface Layer    │  How codebases talk to agents
├─────────────────────────────────┤
│  MCP — Vertical Integration     │  How agents connect to tools/data
├─────────────────────────────────┤
│  A2A — Horizontal Integration   │  How agents talk to each other
└─────────────────────────────────┘

Each one solves a distinct problem. Together, they define how agents interact with code, tools, and each other.

AGENTS.md: the interface layer

Problem it solves: How does an AI agent understand a codebase?

Before AGENTS.md, you'd stuff everything into a system prompt or hope the agent could infer project conventions from file structure. AGENTS.md standardizes this: a single file at the root of your repository that tells agents what they need to know.

# AGENTS.md

## Project Overview
Next.js 16 blog with MDX content and PostgreSQL...

## Commands
npm run dev    # Start dev server
npm run build  # Production build
npm run test   # Run tests

## Architecture
src/app/       # Pages and API routes
src/lib/       # Business logic
content/posts/ # MDX blog posts

This file is designed for non-human consumers as the primary audience. It's not documentation for developers — it's instructions for agents. The distinction matters: agents need concrete commands, file paths, and constraints, not explanations of design philosophy.

AGENTS.md is now in over 60,000 repositories. This blog has a CLAUDE.md file that serves the same purpose — every agent that works on this codebase reads it first.

What to do now: Add an AGENTS.md to every repository your agents touch. Include commands, architecture overview, and constraints. Keep it updated — it's the agent's onboarding document.

MCP: the vertical integration layer

Problem it solves: How does an agent connect to tools and data sources?

The Model Context Protocol (MCP) standardizes how agents call tools. Instead of every framework defining its own function-calling format, MCP provides a universal protocol for tool discovery, invocation, and result handling.

MCP has been adopted by Anthropic, OpenAI, Google, Microsoft, and Amazon. It's hitting 97 million monthly SDK downloads. It's the TCP/IP of agent tooling — boring infrastructure that makes everything else possible.

For this blog, MCP manifests in two ways:

1. Tool definitions — The orchestrator's 10 tools (search_knowledge, write_draft, research_topic, etc.) use OpenAI-compatible function calling, which maps cleanly to MCP
2. Gateway routing — The curate-me.ai gateway speaks OpenRouter's API, which is MCP-compatible for tool calls

What to do now: If you're building agent tools, expose them via MCP. If you're consuming tools, use an MCP-compatible client. This is the baseline — everything else builds on it.

A2A: the horizontal integration layer

Problem it solves: How do agents discover and collaborate with each other?

MCP handles agent-to-tool communication. A2A (Agent-to-Agent protocol) handles agent-to-agent communication. It defines how agents advertise their capabilities, delegate tasks, and exchange results — potentially across organizations.

Google originally developed A2A, and it recently merged with IBM's agent communication protocol under the AAIF umbrella. The combined protocol covers:

• Discovery — Agents publish capability cards describing what they can do
• Delegation — One agent can request work from another with structured task descriptions
• Status — Agents report progress, completion, and failure states
• Results — Structured result delivery with type information

On this blog, A2A manifests in the webhook-driven architecture. The orchestrator delegates research to blog-researcher, writing to blog-writer, and review to the refinement loop. Each delegation follows a pattern compatible with A2A: structured task → agent execution → webhook result.

What to do now: Understand the A2A model even if you don't implement the full protocol yet. The pattern of structured delegation → async execution → result delivery is the right architecture regardless of protocol choice.

How they compose on this blog

Here's how all three standards work together in the daily digest pipeline:

1. AGENTS.md/CLAUDE.md tells blog-dev how the codebase works
2. MCP-compatible tool calls let the orchestrator dispatch tasks
3. A2A-compatible webhooks deliver results between agents:

   blog-researcher (MCP tools: web browser)
     → webhook: research_brief
     → blog-writer (MCP tools: file access)
       → webhook: draft_post
       → refinement loop (MCP tools: gateway LLM call)
         → webhook: draft_revision
         → blog-dev (MCP tools: git, filesystem)
           → webhook: dev_change → published

The curate-me.ai gateway sits at the center, providing governance for every MCP tool call and A2A delegation. Cost caps, PII scanning, audit trails — all enforced at the protocol level.

The AAIF governance layer

Why does it matter that these protocols are in a neutral foundation?

Because vendor lock-in is the enemy of agent governance. If your tool-calling protocol is owned by one vendor, your governance tooling only works with that vendor's ecosystem. With AAIF governance:

• MCP tool calls work with any compliant client
• A2A delegations work across organizational boundaries
• AGENTS.md files work with any agent framework

This is especially important for B2B customers who need to ensure their agent governance infrastructure isn't tied to a single AI provider.

What to adopt now

| Standard | Urgency | Action | |----------|---------|--------| | AGENTS.md | Now | Add to every repo. Takes 30 minutes. Immediate value. | | MCP | Now | Use MCP-compatible tool definitions. Most frameworks already support it. | | A2A | Plan for it | Design your agent communication around structured delegation + async results. Full protocol adoption can come later. |

The protocol landscape has settled. These three standards cover the full stack. The question isn't whether to adopt them — it's how quickly you can align your agent infrastructure.

Check the agents page to see how this blog's fleet uses these patterns, or explore the how it works tour for the full pipeline visualization.