How to Contribute to AAIF: The Real On-Ramp to MCP, goose, AGENTS.md and agentgateway

TL;DR - The Agentic AI Foundation splits cleanly in two. Its governance - Governing Board, Technical Committee, seven working groups - is corporate-member territory, chaired by Platinum members. Its code - four hosted projects - is open to anyone with a GitHub account. If you're an individual engineer, ignore the org chart and go straight to the repos. But each of the four has sharply different house rules, and two of them will close your first PR on sight if you get them wrong. This is that map.

Most "how to contribute to a foundation" guides quietly assume the foundation is the thing you contribute to. For AAIF, that's misleading.

AAIF launched December 9, 2025 and put its structure in place fast: a Governing Board of nine, a Technical Committee with one representative per Platinum member, and seven working groups. Every one of those working groups is chaired by a Platinum member and open "to all membership levels" - which is to say, to members. Your employer joins; you don't.

The code is the opposite. Four hosted projects, all on GitHub, all taking pull requests from strangers this week. That asymmetry is the single most useful thing to understand before you spend a Saturday on this.

What does AAIF actually govern?#

Four hosted projects, as of July 2026:

agentgateway is the newcomer. It joined in June 2026 as the fourth hosted project and the first addition since the foundation opened. Any AAIF explainer written before mid-2026 lists only three projects and is now out of date.

Where does an individual actually fit?#

Three surfaces, in descending order of how open they are to you:

1. Project repos - fully open. Fork, issue, pull request. No membership, no permission.
2. Technical Committee meetings - biweekly, recorded and open to anyone to attend and observe on the LFX platform. You can't vote, but you can watch the requirements for new projects get set in real time. Underrated.
3. Working groups - member-organization territory, chaired by Platinum members. This is the surface an organization joins AAIF to reach.

So the honest sequence for an engineer is: land pull requests in a project first, observe the Technical Committee to learn where the standards are heading, and treat working-group participation as a company-level decision rather than a personal one.

Which project should you start with?#

Match the project to what you already do, because the review bar is high everywhere and domain familiarity is what carries you:

• You write Python and use MCP - the MCP python-sdk. Highest issue volume, clearest labelling, most explicit contribution contract of the four.
• You write Rust and care about infrastructure - agentgateway. Newest, moving fastest, and the surface nearest to Kubernetes work.
• You want the shortest possible first contribution - AGENTS.md. It's a spec plus a Next.js site; docs and compatibility fixes are real, mergeable contributions.
• You build agents day to day - goose. Most active repo, but the least forgiving of a large first pull request.

What are the house rules, per project?#

This is the part that gets people's contributions closed. The four projects have genuinely different contracts, and they're explicit about it.

MCP python-sdk: an issue is mandatory, and declare your AI#

The most rule-dense of the four, and the rules are unusually blunt:

• "All pull requests require a corresponding issue." Anything beyond a typo or broken link needs an issue first. "PRs without a linked issue will be closed."
• An issue alone isn't consent. Wait for maintainer feedback or a ready for work label before you start building.
• AI disclosure is mandatory. One line in the pull request description if you used AI assistance. "Undisclosed AI contributions get closed. Repeat offenders get banned from the modelcontextprotocol org." Autonomous agents filing drive-by pull requests get closed on sight.
• Anything touching the spec itself needs a SEP (spec enhancement proposal) first, not a pull request.

Their issue labels are the cleanest map to available work in the whole foundation: good first issue for newcomers, help wanted for experienced contributors (maintainers likely won't get to it), and ready for work for triaged items.

goose: start small, on purpose#

goose's guide is refreshingly direct about why big first contributions get rejected:

"When a first-time contributor opens a 3k line PR touching 20 files, we have no easy way to tell whether it's thoughtful work or blindly AI-generated without doing a deep dive."

The instruction is explicit: your first contribution should be a small bug fix, ideally linked to an existing issue. Large or cross-cutting changes start as a discussion in the goose-eng Discord, not a pull request. Don't stack contributions; submit in priority order and let each land first. Draft pull requests are for discussion, not for unfinished work.

goose also has the most developed governance of the four projects, with a documented ladder: Contributors, Maintainers, Core Maintainers, the last owning overall technical direction.

agentgateway: Rust, Conventional Commits, LF charter#

Standard Linux Foundation project mechanics:

• Fork, add an upstream remote, branch, rebase on upstream/main before pushing.
• Conventional Commits required: feat:, fix:, docs:, style:, refactor:, perf:, test:, chore:.
• Rust: make lint and make test must pass, and new functionality needs tests. UI: the project's ESLint config, npm run lint, npm test.
• Governed by a formal Technical Charter under LF Projects, LLC. The Technical Steering Committee is the project's Maintainers, and its meetings are intended to be public.

It has the healthiest-looking contributor base of the four: 300+ active contributors across 60+ organizations, including CoreWeave, Red Hat, Adobe, Salesforce, Amdocs, and Microsoft.

AGENTS.md: the spec is the product#

A Next.js site plus the format itself. There's no CONTRIBUTING.md at the repo root, which in practice means normal GitHub etiquette: open an issue, keep the change focused.

Worth knowing before you pick it: upstream's last commit was March 2026. That isn't neglect, it's what a finished spec looks like. The format is stable and the repo is mostly a website around it. Practically, that means low competition and slower review, so choose it for a considered documentation or compatibility contribution rather than a fast first merge.

What does a first pull request look like mechanically?#

The same shape as any Linux Foundation project. Fork, branch, sign off, test, one thing per pull request:

# 1. Fork on GitHub, clone your fork, add upstream
git clone [email protected]:<you>/agentgateway.git && cd agentgateway
git remote add upstream https://github.com/agentgateway/agentgateway.git

# 2. Branch and commit with a Conventional Commit message (-s signs off for DCO)
git checkout -b fix/mcp-route-typo
git commit -s -m "docs: fix typo in MCP routing reference"

# 3. Run the project's gates BEFORE pushing
make lint && make test

# 4. Rebase on upstream, then push and open the pull request
git fetch upstream && git rebase upstream/main
git push origin fix/mcp-route-typo

Three things reviewers reward everywhere: a change that does one thing, a description linking the issue it closes, and green CI on the first push.

Watch the tempo before you pick#

Project activity varies more than the shared foundation branding suggests. As of late July 2026, agentgateway, goose, and the MCP python-sdk were all committing daily, while AGENTS.md had been stable since March. Fast-moving projects mean frequent rebases and quick review; settled projects mean the opposite. Neither is better, but they reward different kinds of contribution, and knowing which you're walking into saves a lot of confusion about why nobody has looked at your pull request yet.

What's the realistic first-90-days plan?#

• Weeks 1-2: pick one project. Build it from source, get its test suite green locally, and read its CONTRIBUTING.md end to end (they differ more than you'd expect). Join goose's Discord or the MCP community channels.
• Weeks 3-6: land one or two small changes: a doc fix, a test, a labelled good first issue. For the python-sdk, open the issue first and wait for ready for work. Small and merged beats ambitious and abandoned.
• Weeks 7-12: take a slightly larger issue, start reviewing others' work, and sit in on a recorded Technical Committee meeting on LFX to see where the standards are going before they ship.

How does this connect to cloud-native work?#

The AAIF and CNCF worlds are not abstract neighbours. kagent, a CNCF Sandbox project, ships native MCP support, and agentgateway is the traffic layer that sits in front of exactly that kind of deployment. An engineer contributing to agentgateway and an engineer contributing to kagent are working two ends of the same stack.

That makes agentgateway the highest-leverage AAIF project for anyone already doing Kubernetes work: it compounds with what you know instead of starting a second, unrelated reputation from zero. If you want the sibling on-ramp, see How to Contribute to CNCF, and What Is the Agentic AI Foundation for the foundation context.

Frequently asked#

How do I contribute to the Agentic AI Foundation?#

Contribute directly to one of its four hosted project repositories on GitHub: MCP, goose, AGENTS.md, or agentgateway. No membership is required for code contributions. AAIF's governance bodies (Governing Board, Technical Committee, and the seven working groups) are corporate-member surfaces, though Technical Committee meetings are recorded and open for anyone to observe on LFX.

Do I need to be an AAIF member to contribute code?#

No. Membership is an organizational tier that grants governance participation, such as board representation and working group seats. The four hosted project repos accept pull requests from any individual contributor.

Which AAIF project is easiest to start contributing to?#

The MCP python-sdk has the clearest labelling (good first issue, help wanted, ready for work) and the most explicit contribution contract. AGENTS.md has the smallest surface area for a quick documentation or compatibility contribution. goose is the most active but explicitly asks first-time contributors to start with a small bug fix.

Will my AI-assisted contribution be rejected?#

Not if you disclose it. The MCP python-sdk requires one line of disclosure in the pull request or issue and closes undisclosed AI contributions, with repeat offenders banned from the org. goose rejects large unexplained first contributions for the same reason. In both cases the requirement is a human who understands and can defend the change, not an absence of AI tooling.

Written by Aman Mundra - founder of Welzin and the Welzin Open Source Software (WOSS), which contributes upstream to the open agentic-AI ecosystem.