Most engineers meet the Agentic AI Foundation the same way we did: through a project, not through the foundation. You reach for the Model Context Protocol because you need an agent to talk to a database. Months later you notice the spec is governed by a foundation you had never heard of.
This post is the other way round.
Where it came from
The Linux Foundation announced the Agentic AI Foundation on 9 December 2025. It did not launch as an empty shell waiting for donations. Three projects were already inside it on day one:
- Model Context Protocol, contributed by Anthropic. The standard way an agent connects to tools, data and systems, so an integration written once works across clients instead of once per vendor.
- goose, contributed by Block. An open source agent that runs on your own machine, against your real environment, and does the whole task rather than suggesting one.
- AGENTS.md, contributed by OpenAI. An ordinary file at the root of a repository where you tell coding agents how to build it, test it, and behave in it.
agentgateway followed: a data plane for agent traffic, doing routing, security and observability between agents, tools and the services behind them.
By launch AAIF had more than 150 member organisations, which made it the fastest-growing foundation in the Linux Foundation's history. Its platinum members are Amazon Web Services, Anthropic, Block, Bloomberg, Cloudflare, Google, Microsoft and OpenAI.
Read that list again. Those companies compete with each other on nearly everything they ship. They agreed on this.
Why a foundation and not a company
MCP is the clearest case for why neutral ground was needed.
It was designed at one company and it worked, so people used it. Then a lot of people used it, and the servers and clients being written against it stopped being something any single vendor could reasonably arbitrate. A protocol that half the industry depends on cannot keep living in one company's repository, because every decision about it starts to look like a competitive move, whether or not it was meant as one.
Donating it changes who gets to decide. The specification, the trademark and the governance sit with a neutral body. Anthropic still contributes heavily, and so do the companies that would never have adopted a protocol on someone else's terms.
This is not a new pattern. It is the same reason Kubernetes went to the Cloud Native Computing Foundation and Node.js went to the OpenJS Foundation. What is new is the speed. The agent stack went from a set of vendor experiments to shared infrastructure in about two years, which is why the governance had to be assembled in a hurry.
What the foundation actually does
Projects are the visible half. The other half is the working groups, and they are where most of the unglamorous work happens. There are eight:
- Accuracy and Reliability
- Agentic Commerce
- Governance, Risk and Regulatory Alignment
- Identity and Trust
- Observability and Traceability
- Security and Privacy
- Workflows and Process Integration
- Taxonomy and Landscape
Look at what that list is worried about. Not model quality. Identity, audit trails, failure behaviour, regulatory exposure, and agreeing on what the words mean. Those are the problems you hit on the second week of running an agent in production, and none of them are solved by a better prompt.
The groups are open. Their calls are public, their documents are public, and nobody checks which country you are joining from.
Ambassadors and chapters
AAIF also appoints ambassadors, and its first cohort covers 138 people across 41 countries. Ayesha Dissanayaka is Sri Lanka's.
That programme is why this chapter exists at all, and it is worth being precise about what a chapter is. We are a community chapter. We run under the foundation's name and its Code of Conduct, we point people at its projects and working groups, and we are not an official channel of the foundation. Nothing said at one of our meetups is an AAIF position. It is a speaker's position, said out loud in a room in Colombo.
Why this should matter to you
If you write software that will touch an agent in the next two years, the interfaces you will be building against are being decided right now, in public, by people who post their calendars.
There are two ways to arrive at that. You can integrate against the result in 2028, or you can read the specs while they are still arguable and say something. The second is not reserved for people at platinum member companies. It requires a GitHub account and the patience to read a thread properly before replying.
That is most of what this chapter is for.