The Agentic AI Foundation — standardizing agentic AI without shooting yourself in the foot
In December 2025, the Linux Foundation announced the creation of the Agentic AI Foundation (AAIF). Three open source projects landed under neutral governance: MCP (Anthropic), goose (Block), and AGENTS.md (OpenAI). Serious backing: AWS, Google, Microsoft, Cloudflare, Bloomberg. Not another marketing coalition — a real attempt to structure the agentic ecosystem before it turns into a mess.
The problem is simple: agentic AI promises to become critical infrastructure, but if every player pushes their own standard, we end up with the fragmentation we know too well from DevOps a decade ago. The AAIF is betting that open governance beats a pile of incompatible APIs.
What changes with the AAIF
Agentic AI is still the wild west. Every platform has its own way of connecting agents to tools, data, and workflows. Some use custom REST APIs, others invent proprietary DSLs, others scrape the DOM and pray it holds together.
The risk is balkanization. If you build an agent today, you pick an ecosystem — Claude, Copilot, Gemini — and you’re stuck. Migrate to another LLM or platform? Rewrite the integrations. Share tools between agents from different providers? Good luck.
The AAIF assumes this situation is unsustainable. For agentic AI to truly become infrastructure — used in prod, scrutinized for reliability, audited for security — you need shared standards. Not just specs on paper, but open source implementations with governance that guarantees no one can unilaterally change the rules.
That’s exactly what happened with Kubernetes. Google created it, then gave it to the Cloud Native Computing Foundation (CNCF) so the entire ecosystem could contribute without fearing vendor lock-in. Result: Kubernetes became the de facto standard for containerized workloads, carried by dozens of players who would never have collaborated if the project had stayed at Google.
The AAIF is playing the same tune, but for agentic AI. Anthropic, Block, and OpenAI give up exclusive control of their projects. MCP, goose, and AGENTS.md become commons, maintained by a community, with a transparent governance process.
The three founding projects
The AAIF doesn’t start from scratch. The three projects that compose it already have real adoption — what changes is that they now evolve under neutral governance.
MCP — the universal connection protocol
Model Context Protocol (MCP) is the standard for connecting LLMs to tools, data, and external APIs. An agent wants to query a database? Read files? Call a third-party API? It goes through MCP.
The protocol defines how a client (an LLM or agent) discovers available tools, how it calls them, and how it receives results. Nothing conceptually revolutionary — it’s JSON-RPC with conventions on data schemas — but adoption changes everything.
Since its launch in November 2024, MCP has been integrated by Claude, Cursor, Microsoft Copilot, Gemini, VS Code, ChatGPT. Over 10,000 MCP servers deployed, covering everything from simple dev tools to Fortune 500 integrations. Anthropic opened the code, published the specs, and now the protocol lives under the AAIF.
What makes MCP relevant is that it solves the discovery problem. An agent connecting to an MCP server immediately receives the list of available tools with their schemas. No need for external documentation, no hardcoded endpoints. The server exposes its capabilities, the agent consumes them.
goose — the local-first agentic runtime
goose is the framework for building and running agents locally. No dependency on a proprietary cloud, no data leaving for a third party. You want an agent that runs on your machine, uses your tools, accesses your files? goose does that natively.
The project combines three elements: a runtime to execute agents, an API to extend their capabilities via custom tools, and MCP integration to plug into the existing ecosystem. goose speaks MCP — so all MCP servers in the world automatically become available to agents built with goose.
Block created goose for its own needs (Square, Cash App, Afterpay) — workflows where data confidentiality and execution control are critical. They opened the code in early 2025, and now the project joins the AAIF.
AGENTS.md — the convention to make code agents reliable
AGENTS.md is the answer to a dumb but omnipresent problem: code agents don’t know how your repo works. What command runs the tests? Where are the specs? What commit convention to use? Without context, the agent guesses — and screws up.
AGENTS.md standardizes this context. It’s a markdown file at the repo root that describes the architecture, workflows, and conventions. Agents that support AGENTS.md read this file before acting, which drastically reduces errors.
Launched by OpenAI in August 2025, the standard has been adopted by over 60,000 open source repos. Cursor, Devin, GitHub Copilot, Gemini CLI, VS Code — all support AGENTS.md. It’s simple, non-intrusive, and it works.
The file itself is minimal: a few markdown sections that document the project’s patterns. But the impact is real. An agent that knows where to find the tests, how to run them, and what the code structure is makes infinitely fewer mistakes than an agent that infers everything from code alone.
graph TD
A[AI Agent] --> B[MCP Client]
B --> C[MCP Server]
C --> D[External Tools]
C --> E[Databases]
C --> F[Third-party APIs]
A --> G[goose Runtime]
G --> H[Local Tools]
G --> I[Filesystem]
G --> B
A --> J[AGENTS.md]
J --> K[Project Context]
K --> L[Code Conventions]
K --> M[Workflows]
K --> N[Architecture]MCP handles connection to external tools. goose provides the local runtime and extensibility. AGENTS.md brings project context to make decisions reliable. Together, they form a coherent stack for building robust agents.
Open governance, critical infrastructure
The AAIF isn’t just a GitHub repo with a Linux Foundation logo. It’s a governance shift with concrete implications.
When Anthropic controlled MCP alone, any protocol evolution depended on its internal priorities. If tomorrow Anthropic decided to pivot to another model, MCP could slow down, stagnate, or diverge. Under the AAIF, that risk disappears. The protocol belongs to the community. Decisions go through a technical committee where members vote. Anthropic has a voice, but no veto.
It’s the same logic that allowed Kubernetes to become critical infrastructure. Google created it, but it was the CNCF that made it indispensable by guaranteeing that Red Hat, Microsoft, AWS, and dozens of other players could contribute equally. Result: Kubernetes became the standard, not the Google solution.
For the AAIF, the bet is identical. MCP, goose, and AGENTS.md have proven their technical relevance. Now, open governance must guarantee their sustainability. A dev who adopts MCP today knows the protocol won’t be abandoned if Anthropic changes strategy. A company deploying goose knows Block can’t close the code tomorrow.
Neutrality is also what enables interoperability. If every player pushes their own standard, nobody wins. If everyone contributes to a shared standard under neutral governance, the entire ecosystem accelerates.
Adoption and ecosystem
A few numbers to situate adoption before the AAIF.
MCP: over 10,000 servers deployed. Native integrations in Claude, Cursor, Microsoft Copilot, Gemini, VS Code, ChatGPT. Companies like Bloomberg use it in prod to connect their agents to real-time financial data. AWS, Google Cloud, and Azure have all announced official support.
AGENTS.md: adopted by over 60,000 open source repos. Native support in Cursor, Devin, GitHub Copilot, Gemini CLI, VS Code, Amp, Codex, Factory, Jules. The convention is simple to add (one markdown file), but the impact on agent reliability is immediate.
goose: active open source framework since early 2025. Used internally at Block (Square, Cash App), but also adopted by external teams who want a local-first runtime. Native MCP integration, so compatible with the entire ecosystem.
The AAIF doesn’t invent anything — it brings order. The projects already exist, devs already use them. What changes is the guarantee that these tools will evolve transparently, collaboratively, and sustainably.
What this means for developers
If you’re building AI agents today, the AAIF concerns you directly.
Guaranteed interoperability: a tool that speaks MCP works with any compatible client. An agent built with goose can use any MCP server. A repo with AGENTS.md is understood by all agents that support the standard. You build once, it works everywhere.
No vendor lock-in: you’re not dependent on Anthropic for MCP, Block for goose, or OpenAI for AGENTS.md. The projects live under neutral governance. If a player leaves, the projects continue. If you want to contribute, there’s a transparent process.
Transparent evolution: roadmaps, technical decisions, breaking change debates — everything happens in public. No surprises. No surprise pivots in press releases. You can follow discussions, propose improvements, vote on major changes if you’re a member.
Now, honesty: it’s still young. MCP is one year old. goose is a few months old. AGENTS.md is a simple convention, but its adoption depends on devs’ willingness to document their projects. The AAIF structures all this, but the bet only holds if the community truly contributes.
Open source foundations work when members invest time, code, and energy. The Linux Foundation has experience (Kubernetes, Node.js, PyTorch, OpenSearch), but it’s up to the agentic ecosystem players to make the AAIF live.
If projects stagnate, if members just display the logo without contributing, if roadmaps become political battlefields, the AAIF will end up like many consortiums: a nice website and poorly maintained repos.
But if it takes off — and the adoption numbers suggest it can — then MCP, goose, and AGENTS.md could become the building blocks on which agentic AI is built for the next ten years.