MCP, A2A, WebMCP, NLWeb, and AGENTS.md: The Standards Powering the Agentic Web

This is Part 3 in a five-part series on optimizing websites for the agentic web. Part 1 covered the evolution from SEO to AAIO. Part 2 explored how to get your content cited in AI responses. This article goes deeper: the protocols forming the infrastructure layer that makes everything else possible.

Updated August 15, 2026: Added WebMCP, which did not exist when this article published and is now default-on across every Shopify Liquid storefront. Updated MCP for the 2026-07-28 specification (stateless protocol core, header-based routing, cacheable list results, a formal extensions framework, a twelve-month deprecation window) and for close to half a billion monthly SDK downloads, up from 97 million. Updated A2A for the v1.0 announcement on April 9, 2026, signed Agent Cards, Azure AI Foundry and Bedrock AgentCore integration, and the AP2 payments protocol with its 60 payments and financial-services organizations. Added an honest status check on NLWeb, whose repository still describes its own code as proof-of-concept fifteen months after launch. Corrected the AAIF membership figure to the 180 organizations the Linux Foundation reported in May 2026, and removed the GitHub Copilot "46% of code" statistic, which cited Octoverse 2024.

In This Series

1. From SEO and CRO to 'AAIO': Why Your Website Needs to Speak to Machines
2. Answer Engine Optimization: How to Get Your Content Into AI Responses
3. MCP, A2A, WebMCP, NLWeb, and AGENTS.md: The Standards Powering the Agentic Web (You are here)
4. How AI Agents See Your Website (And How to Build for Them)
5. Selling to AI: The Complete Guide to Agentic Commerce

The early web needed HTTP to transport data, HTML to structure content, and the W3C to keep everyone building on the same foundation. Without those shared standards, we'd have ended up with a fragmented collection of incompatible networks instead of a single web.

The agentic web is at that same inflection point. AI agents need standardized ways to connect to tools, talk to each other, query websites, and understand codebases. Without shared protocols, every AI vendor builds proprietary integrations, and the result is the same fragmentation the early web narrowly avoided.

Five protocols are emerging as the foundational layer. This article covers what each one does, who's behind it, and what it means for your business. Throughout this series, we draw exclusively from official documentation, research papers, and announcements from the companies building this infrastructure.

Contents

• Why Standards Matter
• MCP: The Universal Adapter
• A2A: How Agents Talk to Each Other
• WebMCP: Your Website as a Set of Callable Tools
• NLWeb: Making Websites Conversational
• AGENTS.md: Instructions for AI Coders
• How the Five Protocols Fit Together
• What the Protocol Stack Means for Your Business
• Key Takeaways

Why Standards Matter

The original web resolved the same problem in the early 1990s, when competing browser vendors and incompatible standards were fragmenting what should have been a unified network. The W3C brought order by establishing shared protocols. HTTP handled transport. HTML handled structure. Everyone agreed on the rules, and the web took off.

AI is at a similar crossroads. Every major AI company is building agents that need to interact with external tools, data sources, other agents, and websites. Without standards, connecting your business systems to AI means building separate integrations for Claude, ChatGPT, Gemini, Copilot, and whatever comes next. That's the M x N problem: M different AI models times N different tools equals an unsustainable number of custom connections.

What makes this moment remarkable is who's building the solution together. On December 9, 2025, the Linux Foundation announced the Agentic AI Foundation (AAIF), a vendor-neutral governance body for agentic AI standards. Eight platinum members anchor it: AWS, Anthropic, Block, Bloomberg, Cloudflare, Google, Microsoft, and OpenAI.

OpenAI, Anthropic, Google, and Microsoft. Competing on AI products, collaborating on AI infrastructure. As Linux Foundation Executive Director Jim Zemlin put it: "We are seeing AI enter a new phase, as conversational systems shift to autonomous agents that can work together."

This is a bigger deal than most people realize. Competitors building shared infrastructure because they all recognize that proprietary standards would hold back the entire ecosystem, including themselves.

The foundation grew quickly after launch. By May 2026 the Linux Foundation counted 180 organizations participating in the AAIF, alongside a 2026 events programme of AGNTCon and MCPCon conferences across North America, Europe, Asia, and Africa. Conference circuits are a lagging indicator of anything technical, but they are a reliable indicator that vendors expect the standard to be around long enough to sponsor.

MCP: The Universal Adapter

What it is: The Model Context Protocol (MCP) is an open standard for connecting AI applications to external tools, data sources, and workflows.

The official analogy is apt: "Think of MCP like a USB-C port for AI applications. Just as USB-C provides a standardized way to connect electronic devices, MCP provides a standardized way to connect AI applications to external systems."

Before MCP, if you wanted your database, CRM, or internal tools accessible to an AI assistant, you had to build a custom integration for each AI platform. MCP replaces that with a single standard interface. Build one MCP server for your data, and every MCP-compatible AI system can connect to it.

The numbers are striking. MCP launched as an open-source project from Anthropic on November 25, 2024. In just over a year, it reached 97 million monthly SDK downloads across Python and TypeScript, with over 10,000 public MCP servers built by the community. Eighteen months in, that figure looks quaint. The 2026-07-28 specification announcement reports "close to half-a-billion downloads a month" across the Tier 1 SDKs, with the TypeScript and Python SDKs each crossing a billion total downloads.

The adoption timeline tells the story. Anthropic's Claude had native MCP support from day one. In March 2025, OpenAI CEO Sam Altman announced support across OpenAI's products, stating: "People love MCP and we are excited to add support across our products." Google followed in April, confirming MCP support in Gemini. Microsoft joined the MCP steering committee at Build 2025 in May, with MCP support in VS Code reaching general availability in July 2025.

From internal experiment to industry standard in 12 months. That pace of adoption signals something real.

The protocol also grew up. The 2026-07-28 specification made the protocol core stateless, so a client no longer needs a handshake or a persistent session to call a server. It added header-based routing through Mcp-Method and Mcp-Name, cacheable list results with TTL hints, and a formal extensions framework covering Tasks, MCP Apps, and Enterprise Managed Authorization. Authorization also hardened, moving from Dynamic Client Registration toward Client ID Metadata Documents. Alongside it came a twelve-month deprecation window policy, which is the sort of thing a protocol adopts when the people running it expect production systems to depend on it for years.

What this means for your business: If your data, tools, or services are MCP-accessible, every major AI platform can use them. That's not a theoretical benefit. It means an AI assistant helping your customer can pull real-time product availability from your inventory system, check order status from your CRM, or retrieve pricing from your database, all through one standardized connection rather than platform-specific integrations.

A2A: How Agents Talk to Each Other

What it is: The Agent2Agent protocol (A2A) enables AI agents from different vendors to discover each other's capabilities and collaborate on tasks.

If MCP is how agents connect to tools, A2A is how agents connect to each other. The distinction matters. In a world where businesses use AI agents from Salesforce for CRM, ServiceNow for IT, and an internal agent for billing, these agents need a way to discover what each other can do, delegate tasks, and coordinate responses. A2A provides that.

Google launched A2A on April 9, 2025 with over 50 technology partners. By June, Google donated the protocol to the Linux Foundation. By July, version 0.3 arrived with over 150 supporting organizations, including Salesforce, SAP, ServiceNow, PayPal, Atlassian, Microsoft, and AWS.

The Linux Foundation announced A2A v1.0 on April 9, 2026, one year to the day after launch, and the protocol now runs under a Technical Steering Committee drawn from AWS, Cisco, Google, IBM Research, Microsoft, Salesforce, SAP, and ServiceNow. Version 1.0 added signed Agent Cards, which matters more than it sounds: if an agent decides what another agent can do by reading a JSON file at a well-known URL, that file becomes worth forging. Microsoft integrated A2A into Azure AI Foundry and Copilot Studio, and AWS added support through Amazon Bedrock AgentCore Runtime, so the protocol is increasingly something enterprises consume through the platforms they already buy rather than something they wire up themselves. The same announcement put 60 organizations across payments and financial services behind AP2.

Payments arrived as a companion protocol. Google announced the Agent Payments Protocol (AP2) for the case where the agent is the one paying, and the FIDO Alliance is developing standards for trusted AI agent interactions on the identity side of the same problem.

The core concept is the Agent Card: a JSON metadata document that serves as a digital business card for agents. Each A2A-compatible agent publishes an Agent Card at a standard web address (/.well-known/agent-card.json) describing its identity, capabilities, skills, and authentication requirements. When one agent needs help with a task, it reads another agent's card to understand what that agent can do, then communicates through A2A to request collaboration.

Google's own framing of how these pieces fit together is useful: "Build with ADK, equip with MCP, communicate with A2A." ADK (Agent Development Kit) is Google's framework for building agents, MCP gives them access to tools, and A2A lets them talk to other agents.

Here's a practical example. A customer contacts your company with a billing question that requires a refund. Your customer service agent (built on one platform) identifies the issue, passes the context to your billing agent (built on another platform) via A2A, which calculates the refund amount and hands off to your payments agent (yet another platform) to process it. The customer sees one continuous interaction. Behind the scenes, three agents from different vendors collaborated through a shared protocol.

The enterprise adoption signal is strong. When Salesforce, SAP, ServiceNow, and every major consultancy sign on to a protocol within months, it's because their enterprise clients are already running into the multi-vendor agent coordination problem that A2A solves.

WebMCP: Your Website as a Set of Callable Tools

What it is: WebMCP lets a website expose its own features to AI agents as structured, callable tools, through a browser API rather than a server you run. It is a working draft at the W3C Web Machine Learning Community Group.

WebMCP did not exist when this article first published. It is now the protocol on this list most likely to show up on your website without you doing anything.

The distinction from MCP is where the code lives. An MCP server is infrastructure you host, and it answers to any AI client that connects. WebMCP runs inside the page the user already has open, in their browser session, with their cookies and their login. A page calls document.modelContext.registerTool() to declare what it can do, and an agent calls getTools() to see the list and executeTool() to run one. There is a toolchange event for tools that come and go as the page changes.

That session detail is the whole point. An agent using an MCP server has to be granted its own credentials. An agent using WebMCP acts inside a session the human already authenticated, which is why it suits the "help me finish this task on this website" case that MCP servers handle awkwardly.

Why it matters now: Shopify announced on August 5, 2026 that WebMCP tools would be exposed on every Liquid storefront and the Hydrogen developer preview, with an effective date of August 21 and an API reference to match. The changelog is blunt about how little merchants have to do: "There's nothing to install or configure." Every storefront serves the same Shopify-written tool descriptions, which is either sensible standardization or the total erasure of brand voice at the agent layer, depending on where you sit.

The catch is browser support. WebMCP is in a Chrome origin trial, so document.modelContext is undefined unless the page serves an origin trial token or the visitor has enabled experimental web platform features. A page can register perfectly correct tools and have none of them exist for an ordinary visitor, with no error to say so. Feature-detect before you assume anything registered.

For the full treatment, including the API surface and the security questions that come with handing agents callable tools, see What Is WebMCP? and the tools you expose can be used to hijack agents.

NLWeb: Making Websites Conversational

What it is: NLWeb (Natural Language Web) is an open project from Microsoft that turns any website into a natural language interface, queryable by both humans and AI agents.

NLWeb is about your website rather than your developers, which is what made it the one to watch in early 2026. Fifteen months after launch it is also the slowest-moving protocol on this list, and that gap is worth being honest about.

NLWeb was introduced at Microsoft Build 2025 on May 19, 2025. It was conceived and developed by R.V. Guha, who joined Microsoft as CVP and Technical Fellow. If that name sounds familiar, it should: Guha is the creator of RSS, RDF, and Schema.org, three standards that fundamentally shaped how the web organizes and syndicates information. When the person behind Schema.org builds a new web protocol, it's worth paying attention.

The key insight behind NLWeb is that websites already publish structured data. Schema.org markup, RSS feeds, product catalogs, recipe databases. NLWeb reads these existing formats and combines them with AI, so users and agents can query a website's content in natural language instead of clicking through pages.

Microsoft's framing is deliberate: "NLWeb can play a similar role to HTML in the emerging agentic web." The NLWeb README puts it even more directly: "NLWeb is to MCP/A2A what HTML is to HTTP."

Every NLWeb instance is automatically an MCP server. That means any website running NLWeb immediately becomes accessible to the entire ecosystem of MCP-compatible AI assistants and agents. Your website's content doesn't just sit there waiting for visitors. It becomes actively queryable by any AI system that speaks MCP.

Early adopters include Eventbrite, Shopify, Tripadvisor, O'Reilly Media, Common Sense Media, and Hearst. These are content-rich websites that already invest heavily in structured data. NLWeb builds directly on that investment.

Here's what this looks like in practice. Instead of a user navigating Tripadvisor's search filters to find family-friendly restaurants in Barcelona with outdoor seating, an AI agent could query Tripadvisor's NLWeb endpoint: "Find family-friendly restaurants in Barcelona with outdoor seating and good reviews." The response comes back as structured Schema.org JSON, ready for the agent to present to the user or act on.

If your business has already invested in Schema.org markup (and Part 2 of this series explained why you should), you're closer to NLWeb readiness than you might think.

The honest status update. NLWeb has not moved at the pace of the other protocols on this list. The repository still describes its implementation code as "proof-of-concept demonstrations showing one possible approach" rather than a definitive solution, and hosted deployment on GCP and AWS is still listed as coming soon. The adopter list has grown, adding Chicago Public Media and Allrecipes to the launch names, but there is no plugin ecosystem, no CMS integration worth the name, and no default-on distribution of the kind WebMCP got through Shopify. Treat NLWeb as a well-designed idea from the person who built Schema.org, moving on standards-body time rather than browser-vendor time. The Schema.org work it depends on pays off regardless, which is the reason to keep doing that work and stop waiting on this specific protocol to justify it.

AGENTS.md: Instructions for AI Coders

What it is: AGENTS.md is a standardized Markdown file that provides AI coding agents with project-specific guidance, essentially a README written for machines instead of humans.

This protocol is less directly relevant to the marketers and strategists reading this series, but it's an important piece of the complete picture, especially if your organization has development teams using AI coding tools.

AGENTS.md emerged from a collaboration between OpenAI Codex, Google Jules, Cursor, Amp, and Factory. The problem they were solving: AI coding agents need to understand project conventions, build steps, testing requirements, and architectural decisions before they can contribute useful code. Without explicit guidance, agents make assumptions that lead to inconsistent, buggy output.

Since its release in August 2025, AGENTS.md has been adopted by over 60,000 open-source projects and is supported by tools including GitHub Copilot, Claude Code, Cursor, Gemini CLI, VS Code, and many others. It's now governed by the Agentic AI Foundation, alongside MCP.

The file itself is simple. Plain Markdown, typically under 150 lines, covering build commands, architectural overview, coding conventions, and testing requirements. Agents read it before making any changes, getting the same tribal knowledge that senior engineers carry in their heads.

When a meaningful share of the code entering your repository is written by an agent rather than a person, a standard way to hand those agents your conventions, security practices, and architectural patterns stops being a nice-to-have. It is the quality control you already apply to human contributors at review time, moved earlier.

Why this matters for your business: If your development teams use AI coding tools (and most do), AGENTS.md ensures those tools produce code that matches your standards. It reduces agent-generated bugs, cuts onboarding time for AI tools on new projects, and provides consistency across teams.

How the Five Protocols Fit Together

The five protocols are complementary layers in the same stack rather than competitors.

The stack works like this: MCP provides the plumbing for agents to access tools and data. A2A enables agents to coordinate with each other. NLWeb makes website content accessible to the entire ecosystem. AGENTS.md ensures AI coding agents build correctly. And the Agentic AI Foundation provides the governance layer that keeps these protocols open, vendor-neutral, and interoperable.

The parallel to the original web is impossible to ignore:

• HTTP (transport) maps to MCP (tool access) and A2A (agent communication)
• HTML (content structure) maps to NLWeb (website content for agents)
• W3C (governance) maps to AAIF (governance)

What's different this time is the speed, though not uniformly. HTTP took years to gain broad adoption. MCP went from launch to universal platform support in 12 months and to roughly half a billion monthly SDK downloads in under two years. A2A grew from 50 to 150+ partner organizations in three months and reached v1.0 within a year. AGENTS.md reached 60,000 projects within its first few months. WebMCP went from a working draft to default-on across every Shopify Liquid storefront inside six months.

NLWeb is the exception, and the contrast is instructive. It launched with the strongest pedigree of the five and the most obvious relevance to website owners, and it has moved the slowest. Distribution beat design: One Shopify platform decision put WebMCP on more websites than NLWeb has reached in fifteen months of being a better-known idea.

The infrastructure is being built at internet speed, not standards-committee speed. That's partly because the companies involved are the same ones building the agents that need these protocols. They're motivated.

These five aren't the only protocols emerging. Commerce-specific standards are building the transaction layer: Shopify and Google co-developed the Universal Commerce Protocol (UCP), launched in January 2026 with support from Etsy, Target, Walmart, and Wayfair. OpenAI and Stripe co-developed the Agentic Commerce Protocol (ACP), which powers Instant Checkout in ChatGPT. CopilotKit's AG-UI protocol addresses agent-to-frontend communication, with integrations from LangGraph, CrewAI, and Google ADK. We'll cover the commerce protocols in depth in Part 5.

What the Protocol Stack Means for Your Business

You don't need to implement all five protocols tomorrow. But you need to understand what's being built, because it shapes what your website, tools, and teams should be ready for.

If you run a website on a major platform, check what it already exposes. This is the newest item on the list and the most immediate. If you are on Shopify, your storefront exposes WebMCP tools whether or not you knew, following the August 5, 2026 announcement. Open your storefront in Chrome and run await document.modelContext.getTools() in the console to see what an agent sees. If the call returns undefined, the API is not exposed on that page, which is the expected result outside the Chrome origin trial. What comes back, or does not, is your website as an agent encounters it.

If you've already invested in Schema.org markup, keep that work current, but do it because structured data pays off across AI search, rich results, and your own internal systems, not because NLWeb is about to arrive. NLWeb builds directly on the structured data you already maintain and remains the cleanest design for conversational access to a website. It is also fifteen months into a slow adoption curve with no platform distribution behind it.

If you have APIs or internal tools, consider MCP accessibility. Making your services available through MCP means any AI platform can interact with them. For e-commerce, that could mean product catalogs, inventory systems, and order tracking becoming accessible to AI shopping assistants across ChatGPT, Claude, Gemini, and whatever comes next.

If you're evaluating multi-vendor agent workflows, A2A is the protocol to watch. Enterprise organizations running agents from multiple vendors (Salesforce, ServiceNow, internal tools) will increasingly need these agents to coordinate. A2A is the emerging standard for that coordination.

If your development teams use AI coding tools, adopt AGENTS.md now. It's the simplest protocol to implement (it's a single Markdown file) and the one with the most immediate, tangible benefit: fewer bugs, more consistent output, faster onboarding for AI tools on your codebase.

The underlying message across all five protocols is the same: the agentic web is being built on open standards, not proprietary ones. The companies that understand these standards early will be better positioned as AI agents become a primary way users interact with businesses.

These aren't things you need to implement today. But they are things you need to understand, because Part 4 of this series gets into the technical specifics of making your website agent-ready.

Key Takeaways

• Five protocols form the agentic web's infrastructure. MCP (tools), A2A (agent communication), WebMCP (a website's own features as callable tools), NLWeb (website content), and AGENTS.md (code guidance) are complementary layers, not competitors.

• The speed of adoption signals real urgency. MCP reached close to half a billion monthly SDK downloads by July 2026 and released a reworked stateless specification. A2A reached v1.0 in April 2026 with signed Agent Cards and GA support inside Copilot Studio, Azure AI Foundry, and Bedrock AgentCore. These are not experiments.

• Competitors are collaborating on infrastructure. OpenAI, Anthropic, Google, and Microsoft are all building shared protocols under the Agentic AI Foundation, which counted 180 participating organizations by May 2026. This mirrors the W3C moment that unified the early web.

• WebMCP is the protocol most likely to reach your website first. Shopify announced on August 5, 2026 that every Liquid storefront would expose WebMCP tools, with nothing for merchants to install or configure. Browser support is still gated behind a Chrome origin trial, so feature-detect rather than assume.

• NLWeb is the best-designed protocol on this list and the slowest-moving. Built by the creator of Schema.org, it turns existing structured data into a conversational interface, and every NLWeb instance is automatically an MCP server. It still describes its own code as proof-of-concept. Distribution beat design here.

• MCP is the universal adapter. Build one MCP connection to your data, and every major AI platform (Claude, ChatGPT, Gemini, Copilot) can access it. No more building separate integrations for each platform.

• Start with what you have. Existing APIs can become MCP servers. Schema.org markup pays off across AI search whether or not NLWeb arrives. AGENTS.md is a single file your dev team can create today. If you are on Shopify, WebMCP is already running and worth inspecting. You don't need to start from scratch.

The original web succeeded because competitors agreed on shared standards. The agentic web is following the same playbook, just faster. The protocols are being established now. The governance is in place. The agents are already using them.

Up next in Part 4: the hands-on technical guide for making your website ready for autonomous AI agents, from semantic HTML to accessibility standards to testing with real agent tools.