OpenAI, Google, Anthropic Launch Agentic AI Foundation — Why Open Standards Matter Now

On December 9, 2025, OpenAI, Anthropic, Google, Microsoft, AWS, Block, Bloomberg, and Cloudflare launched the Agentic AI Foundation (AAIF) under the Linux Foundation, with Anthropic's MCP, Block's goose, and OpenAI's AGENTS.md as founding projects. Google's A2A protocol has since joined as a hosted project. The practical question for anyone building or buying AI agents: these are the protocols your agents will use to connect to tools and to each other, and they are no longer controlled by any single vendor.

This isn't about competition. It's about making AI agents compatible — and it changes how you should evaluate every AI tool and vendor from now on.

What AAIF Actually Does

The Agentic AI Foundation is a neutral home for the open building blocks of agentic AI. Its project stack now covers five distinct layers:

MCP (Model Context Protocol): Anthropic's open standard for connecting AI models to tools, data sources, and applications — the official documentation describes it as a "USB-C port for AI applications." An MCP server exposes a database, an API, or a workflow once; any MCP-compatible agent (Claude, ChatGPT, Cursor, VS Code, and others) can then use it without custom integration code. MCP is about agent-to-tool connectivity, not memory or session management.

AGENTS.md: OpenAI's donated standard — a simple Markdown file that gives AI coding agents consistent, project-specific instructions (how to build, test, and contribute) across repositories and toolchains.

goose: Block's open-source, local-first AI agent framework — the runtime layer in which an agent reasons, plans, and invokes MCP-based tools.

A2A (Agent2Agent): Google's protocol for inter-agent communication — how independent agents discover each other via "agent cards," delegate tasks, and exchange results across frameworks and vendors. Google launched A2A in April 2025 and donated it to the Linux Foundation; IBM's Agent Communication Protocol merged into it in August 2025, and A2A v1.0 shipped in March 2026 with signed agent cards for cryptographic identity verification, multi-tenancy, and version negotiation.

agentgateway: the operations layer — a gateway that sits between agent systems and infrastructure, handling routing, policy, and observability for agent traffic.

All of these are open-source and governed by AAIF, which means:

• Neutral governance (no single company controls the specs)
• Public contribution process
• Enterprise-grade stability guarantees

The platinum members funding this are AWS, Anthropic, Block, Bloomberg, Cloudflare, Google, Microsoft, and OpenAI, with gold members including Cisco, Docker, IBM, Oracle, Salesforce, SAP, and Snowflake, per the Linux Foundation announcement.

Why This Matters Right Now

AI agents are moving from demos to production. Companies are building systems where multiple AI agents handle different tasks — one agent for customer queries, another for database access, a third for scheduling.

Without standards, every integration is custom. You end up with:

• Brittle point-to-point connections
• Vendor lock-in (switching agents means rewriting integrations)
• Security nightmares (no standard authentication/authorization patterns)
• Debugging hell (no shared logging or observability formats)

AAIF addresses all of this by defining common protocols. It's the same playbook that worked for HTTP, SMTP, and OAuth — boring infrastructure that enables innovation at higher layers.

This is no longer theoretical. A2A is backed by more than 150 organizations and already runs in production: Huawei uses it as the protocol between its HarmonyOS assistant and in-app agents, Tencent's WeChat integrates with Android OEM assistants over A2A, and all three major clouds (Google Cloud, Azure AI Foundry, AWS Bedrock AgentCore) support building and hosting A2A agents, according to the AAIF's A2A announcement.

The Real Technical Challenge: Multi-Agent Coordination

Building a single AI agent that works is table stakes. The hard problem is making multiple agents work together reliably.

Consider a typical business workflow:

1. Customer sends inquiry via voice AI agent
2. Agent checks inventory (calls database agent)
3. Agent verifies pricing (calls pricing agent)
4. Agent schedules delivery (calls logistics agent)
5. Agent confirms order (responds to customer)

Without standards, each handoff is custom code. With MCP and A2A:

• Context flows automatically (customer intent, conversation history)
• Authentication is standardized (each agent verifies permissions)
• Failure handling is consistent (retry logic, fallback patterns)
• Observability is built-in (trace requests across agents)

This is what enterprises need to deploy AI agents at scale.

What the Working Groups Tell You About the Roadmap

A standards body's working groups are a reliable map of where enterprises are hitting walls. AAIF's working groups cover:

• Accuracy & Reliability — SLAs, failure management, and recovery protocols for autonomous systems
• Identity & Trust — portable agent identity, delegation, and how permissions flow across agent-to-agent interactions
• Security & Privacy — security-by-design benchmarks and adversarial testing for agents
• Observability & Traceability — execution tracing, audit, and forensics across platforms
• Governance, Risk & Regulatory Alignment — risk classification and mapping to regulations like the EU AI Act
• Agentic Commerce — discovery, negotiation, and payment authorization for autonomous transactions
• Workflows & Process Integration — handoff protocols and state guarantees for multi-step business processes

Read that list as a buyer's checklist. If a vendor's agent platform has no answer for identity, observability, or audit, it will struggle to pass an enterprise security review no matter how good the demo looks. We covered the monitoring side in our guide to AI agent monitoring and observability.

What This Means For Your Business

If you're building AI products: Start adopting MCP and A2A now. Early support means compatibility with a growing ecosystem of tools and agents. It's the difference between building closed systems and building composable systems.

If you're buying AI solutions: Ask vendors about MCP and A2A support specifically. Agents that support them will integrate more easily with future tools. Avoid solutions that rely entirely on proprietary protocols — you're buying vendor lock-in.

If you're evaluating AI strategy: Multi-agent architectures are becoming the standard for complex workflows. Plan for a world where your AI systems are composed of specialized agents from different vendors, all communicating via standard protocols. Our AI agent orchestration best practices post covers the architecture patterns in detail.

A concrete first step: pick one internal system your agents need (a CRM, a ticket queue, a document store) and expose it through an MCP server instead of a bespoke API integration. That single move makes the system usable by every MCP-compatible agent you adopt later. This is exactly the kind of work our Claude implementation service does — MCP servers, skills, and agent workflows — and for regulated environments our enterprise AI practice covers the governance documentation and private deployment around it.

When Open Standards Are the Wrong Priority

Standards are not free. Be honest about the trade-offs:

• Single-agent, single-vendor setups gain little. If one agent from one vendor does the whole job, wrapping everything in MCP adds moving parts without paying back.
• The specs are young. A2A v1.0 shipped in March 2026. Expect breaking changes in tooling and gaps in SDKs, especially outside Python and TypeScript.
• Standards don't fix bad design. MCP gives an agent a standard way to reach your database; it does nothing to stop a badly-scoped agent from querying the wrong table. Permissions, scoping, and evaluation are still your job.
• Governance takes time. Linux Foundation processes are deliberate. If you need a protocol feature next month, build it yourself and contribute it back later.

The right framing: adopt MCP/A2A at the integration boundaries, keep your agent logic portable, and don't bet a production deadline on a spec that is still a draft.

The Competitive Implications

This is a rare moment of industry alignment. Why did competitors agree to collaborate?

For OpenAI and Anthropic: They compete on AI model quality, not infrastructure protocols. Open standards expand the market — more developers build agents, more enterprises adopt them, everyone wins.

For Google and Microsoft: They need developers to build on their cloud platforms. Standard protocols make it easier to deploy multi-cloud agent architectures, which increases cloud consumption.

For AWS: infrastructure providers benefit from standard protocols the same way AWS benefited from Kubernetes — the standard doesn't pick winners, it grows the market. For Block: goose is its agent framework; donating it buys influence over the ecosystem and goodwill with developers at low cost.

The players who lose are vendors with proprietary agent frameworks that refuse to adopt open standards. History suggests they'll either adapt or become irrelevant.

What Comes Next

AAIF follows the Linux Foundation model: public roadmaps and working groups, open contribution, reference implementations, and compliance testing. Some of what was prediction when the foundation launched has already happened:

• The stack is filling out — A2A joined MCP, goose, and AGENTS.md, and agentgateway added an operations layer. Expect further donations; the Linux Foundation model tends to vacuum up adjacent open-source projects, as it did with Kubernetes ecosystem tooling.
• A stable spec exists — A2A v1.0 shipped in March 2026, which gives enterprises a fixed target to build against for the first time.
• Commerce is the next frontier — Google Cloud and PayPal are extending A2A with the Agent Payments Protocol (AP2) so shopping and merchant agents can handle payment authorization.
• Enterprise adoption accelerates — CIOs trust Linux Foundation governance; neutral stewardship removes a real blocker for production deployments.

For the broader context on why these rivals are cooperating, see our companion analysis of the Agentic AI Foundation and open-source agent standards.

The Bottom Line

The formation of AAIF signals that AI agents are transitioning from research projects to enterprise infrastructure. Open standards are how the industry scales — not by every company reinventing protocols, but by agreeing on common foundations.

If you're building AI systems, pay attention to MCP and A2A. If you're buying AI solutions, demand protocol compatibility. If you're skeptical, remember what happened to messaging platforms that refused to support standard protocols.

The agentic AI era is here. AAIF is building the roads.

Frequently asked questions

What is the Agentic AI Foundation (AAIF)?

AAIF is a Linux Foundation organization announced on December 9, 2025 that provides neutral, open governance for the core building blocks of agentic AI. Its founding projects are Anthropic's MCP, Block's goose, and OpenAI's AGENTS.md, with Google's A2A protocol and agentgateway added since.

What is the difference between MCP and A2A?

MCP connects an agent to tools, data sources, and applications — agent-to-tool. A2A connects agents to other agents across vendors and frameworks — agent-to-agent. Most real deployments need both: MCP so each agent can reach systems, A2A so agents can delegate work to each other.

Who are the members of AAIF?

Platinum members are AWS, Anthropic, Block, Bloomberg, Cloudflare, Google, Microsoft, and OpenAI. Gold members include Cisco, Docker, IBM, Oracle, Salesforce, SAP, Shopify, and Snowflake, alongside dozens of silver members.

Do I need to adopt MCP and A2A right now?

If you build AI products or multi-agent workflows, yes — start with MCP for tool access because the ecosystem is already broad. If you run a single agent from a single vendor, you can wait; the payoff comes at integration boundaries, not inside one self-contained agent.

Is A2A production-ready?

A2A v1.0 shipped in March 2026 and is running in production at Huawei, Tencent, and across Google Cloud, Azure AI Foundry, and AWS Bedrock AgentCore. That said, the tooling around it is young, so plan for SDK gaps and version churn.

Where to go from here

If you want to put these standards to work, the pragmatic starting point is one MCP server in front of one system your agents need, then growing from there. Our Claude implementation service builds exactly that — MCP servers, agent skills, and workflows that stay portable because they sit on open protocols.