AI agents are evolving from chat wrappers into systems that connect to tools, communicate with other agents, and run in production. But the infrastructure underneath, the protocols, runtimes, gateways, and conventions, is still being built. That's where the Agentic AI Foundation (AAIF) comes in.
AAIF is an open and neutral home at the Linux Foundation for the standards, protocols, and open source projects that make agentic AI work. I was recently selected as an AAIF Ambassador, and this post is my attempt to map out the four core projects, how they fit together, and, most importantly, where you can start contributing today.
Table of Contents
- The Four AAIF Projects
- How They Work Together
- Connected Open Source Projects
- Contributing: Where to Start
- Get Involved
The Four AAIF Projects
MCP: The Protocol for Agent-Tool Communication
Model Context Protocol (MCP) is the foundational layer. It standardizes how AI agents connect to tools, data sources, and services. Think of it as a universal adapter between any agent and any tool.
MCP servers expose three core primitives:
-
Tools: Functions the agent can call (e.g.,
search_code,execute_query) - Resources: Data the agent can read (e.g., files, database schemas)
- Prompts: Reusable templates for common agent tasks
The protocol uses JSON-RPC 2.0 over multiple transports (stdio, SSE, Streamable HTTP). Build an MCP server once, and any MCP-compatible agent can use it. No more rebuilding integrations per framework.
The current spec version uses date-based versioning (2025-11-25) and includes OAuth authentication, progress notifications, logging, and sampling (servers requesting LLM completions through the client).
The ecosystem is large. Official SDKs exist in 10 languages: TypeScript, Python, Go, Rust, Java, Kotlin, Swift, C#, PHP, and Ruby. There are 7 reference servers (filesystem, git, memory, fetch, sequential thinking, time, everything) and an MCP Inspector for testing and debugging.
| Repo | modelcontextprotocol/modelcontextprotocol |
| Language | TypeScript (spec + schema), MDX (docs) |
| License | Apache 2.0 (code), CC-BY 4.0 (docs) |
| Docs | modelcontextprotocol.io |
Goose: A General-Purpose AI Agent
Goose is where MCP comes to life. It's an open source AI agent built in Rust with a native desktop app (macOS, Linux, Windows), a CLI, and an API server.
Goose isn't just a coding agent. You can use it for research, writing, automation, and data analysis. It connects to 70+ MCP extensions and supports 15+ LLM providers (Anthropic, OpenAI, Google, Ollama, OpenRouter, Azure, Bedrock, and more). You can also use existing Claude, ChatGPT, or Gemini subscriptions via ACP (Agent Client Protocol).
The Rust workspace is organized into focused crates:
crates/
├── goose # core agent logic
├── goose-cli # CLI entry point
├── goose-server # backend (binary: goosed)
├── goose-mcp # MCP extension integrations
├── goose-acp-macros # ACP proc macros
└── goose-test # test utilities
ui/desktop/ # Electron desktop app
Development uses Hermit for reproducible tooling and just for task automation.
| Repo | aaif-goose/goose |
| Language | Rust (edition 2021, min rustc 1.91.1), TypeScript (Electron UI) |
| License | Apache 2.0 |
| Docs | goose-docs.ai |
AGENTS.md: A README for Agents
AGENTS.md solves a specific problem: README files aren't written for AI agents. They tell humans what a project does, but they don't give an agent the build commands, test patterns, and conventions it needs to actually work on the codebase.
An AGENTS.md file is a dedicated, predictable place for agent-specific context:
## Dev environment tips
- Use `pnpm dlx turbo run where <project_name>` to jump to a package.
- Check the name field inside each package's package.json to confirm the right name.
## Testing instructions
- Run `pnpm turbo run test --filter <project_name>`.
- Add or update tests for the code you change, even if nobody asked.
## PR instructions
- Title format: [<project_name>] <Title>
- Always run `pnpm lint` and `pnpm test` before committing.
No spec, no protocol. Just a convention. The repository includes a Next.js website at agents.md with examples and a community showcase.
Notably, several AAIF projects already use AGENTS.md files themselves. Goose's CLAUDE.md points to its own AGENTS.md. The MCP spec repo, MCP Inspector, and MCP Go SDK all have AGENTS.md files guiding contributors and agents alike.
| Repo | anthropics/agents.md |
| Language | TypeScript (Next.js), Tailwind CSS |
| License | MIT |
| Site | agents.md |
AgentGateway: Production Infrastructure for Agents
AgentGateway is a Rust-based proxy that sits between your agents, LLMs, tools, and other agents. It provides drop-in security, observability, and governance for agentic traffic.
It handles three types of communication:
- LLM Gateway: Routes to LLM providers (OpenAI, Anthropic, Gemini, Bedrock, etc.) through a unified OpenAI-compatible API with budget controls, prompt enrichment, load balancing, and failover.
- MCP Gateway: Connects agents to tools via MCP with tool federation, multi-transport support, OpenAPI integration, and OAuth authentication.
- A2A Gateway: Enables agent-to-agent communication using Google's A2A protocol with capability discovery and task collaboration.
Production features include:
- Auth: JWT, API keys, OAuth, fine-grained RBAC with CEL policy engine
- Guardrails: regex filtering, OpenAI moderation, AWS Bedrock Guardrails, Google Model Armor, custom webhooks
- Observability: OpenTelemetry metrics, logs, and distributed tracing
- Inference routing: Kubernetes Inference Gateway extensions with GPU utilization, KV cache, and LoRA adapter awareness
From the project charter:
The mission is to create a secure, scalable, and standardized foundation for AI agents to discover, communicate with, and leverage external tools and services.
| Repo | agentgateway/agentgateway |
| Language | Rust (edition 2024, min rustc 1.90), TypeScript (UI) |
| License | Apache 2.0 |
| Docs | agentgateway.dev |
How They Work Together
- MCP defines how agents connect to tools (the protocol)
- Goose is an agent that uses MCP (the runtime)
- AgentGateway provides infrastructure to operate MCP/LLM/A2A traffic securely at scale (the proxy)
- AGENTS.md gives agents the context they need to work on your codebase (the convention)
Connected Open Source Projects
AAIF projects don't exist in isolation. Here are key open source projects in their orbit:
MCP Ecosystem
| Project | What It Does | Link |
|---|---|---|
| MCP TypeScript SDK | Build MCP clients/servers in TypeScript | modelcontextprotocol/typescript-sdk |
| MCP Python SDK | Build MCP clients/servers in Python | modelcontextprotocol/python-sdk |
| MCP Go SDK | Build MCP clients/servers in Go | modelcontextprotocol/go-sdk |
| MCP Rust SDK (rmcp) | Rust SDK used by Goose internally | modelcontextprotocol/rust-sdk |
| MCP Reference Servers | 7 reference implementations (filesystem, git, memory, etc.) | modelcontextprotocol/servers |
| MCP Inspector | Developer tool for testing/debugging MCP servers | modelcontextprotocol/inspector |
| MCP Registry | Discover community-built MCP servers | registry.modelcontextprotocol.io |
Agent & Infrastructure Ecosystem
| Project | What It Does | Relationship |
|---|---|---|
| A2A Protocol | Google's Agent-to-Agent protocol | AgentGateway implements A2A Gateway |
| Kubernetes Gateway API | Standard K8s ingress/gateway | AgentGateway extends it for inference routing |
| OpenTelemetry | Observability framework | AgentGateway exports OTEL metrics/logs/traces |
| Ollama | Run LLMs locally | Goose uses Ollama as a provider for local inference |
| OpenRouter | Multi-provider LLM routing | Goose supports OpenRouter as a provider |
| KServe | ML model serving on Kubernetes | Complementary inference infrastructure |
| MarkItDown | Document-to-Markdown converter | Useful for feeding documents to MCP resources |
Contributing: Where to Start
Difficulty Ranking
Not all projects require the same level of expertise. Here's a practical ranking based on the actual contributing guides, toolchain requirements, and codebase complexity:
| Rank | Project | Barrier to Entry | Best First Contribution |
|---|---|---|---|
| 1 (Easiest) | AGENTS.md | Node.js + pnpm | Add an example, improve docs |
| 2 | MCP Spec | Node.js 24+ | Fix docs, improve examples |
| 3 | Goose | Rust + Hermit + Cargo | Small bug fix linked to an issue |
| 4 (Hardest) | AgentGateway | Rust 1.90+ + npm + Make + (optionally K8s) | Bug fix, docs improvement |
1. AGENTS.md · Easiest Entry Point
Why it's easiest: It's a Next.js website. If you know TypeScript and React, you can contribute immediately. There's no spec to learn, no protocol to understand.
Setup:
git clone https://github.com/YOUR-USERNAME/agents.md.git
cd agents.md
pnpm install
pnpm run dev # http://localhost:3000
Coding standards:
- TypeScript (
.tsx/.ts) for new components - Use the dev server (
pnpm run dev), never runnpm run buildduring development, it breaks HMR - Co-locate component styles with components
- Run
npm run lintbefore submitting
What to contribute:
- Add AGENTS.md examples from real-world projects (monorepos, Python packages, Rust crates)
- Improve the website design or UX
- Write documentation explaining best practices for writing AGENTS.md files
- Add case studies showing how AGENTS.md improved agent effectiveness
2. MCP Specification · Docs and Schema
Why it's accessible: The spec repo is TypeScript-based with clear tooling. Documentation contributions are the easiest path in, and the project explicitly welcomes them.
Setup:
git clone https://github.com/YOUR-USERNAME/modelcontextprotocol.git
cd modelcontextprotocol
nvm install # correct Node version
npm install
npm run serve:docs # preview docs locally
Quality gate before submitting:
npm run prep # runs all checks, generates schemas, formats code
Coding standards:
- Schema source of truth:
schema/draft/schema.ts(TypeScript → generates JSON Schema + MDX) - Docs: MDX format in
docs/, blog: Hugo inblog/ - Date-based spec versioning (YYYY-MM-DD), NOT semver
-
npm run formatfor code formatting -
npm run check:docs:linksto verify no broken links
AI disclosure required: If you use any AI assistance, you must disclose it in your PR description, along with the extent of use. MCP will close PRs that don't comply.
What to contribute:
- Fix or improve documentation pages (MDX in
docs/) - Add schema examples (JSON files in
schema/[version]/examples/[TypeName]/) - Write blog posts for the Hugo blog (
blog/) - Propose spec changes via the SEP process (review the design principles first)
- Contribute to SDKs in your preferred language (Go, Python, TypeScript, Rust, etc.)
Tip: The MCP Inspector (npx @modelcontextprotocol/inspector) is a great way to learn MCP interactively before contributing.
3. Goose · Rust Agent Framework
Why it's moderate: Goose is a large Rust workspace. The barrier is Rust fluency and the Hermit-managed toolchain. But the project has clear contributing docs and a strong code review culture.
Setup:
git clone https://github.com/YOUR-USERNAME/goose.git
cd goose
source bin/activate-hermit # installs Rust, Node, pnpm, just
cargo build
cargo test
Quality gate before submitting:
cargo fmt
cargo clippy --all-targets -- -D warnings
cargo test
# If you changed server APIs:
just generate-openapi
Contributing rules:
- Start small. First PRs should be small bug fixes linked to existing issues. Large first PRs will be closed with a redirect to the contributing guide. Don't take it personally.
- Don't open many PRs at once. Submit in order of preference, wait for them to land.
-
Conventional Commits required (
feat:,fix:,docs:, etc.) - No AI disclosure needed, but you're responsible for the final code. "Vibe coded" submissions that skip human review will be closed.
- AI code review is used. The project runs Codex as a reviewer. Address all its comments or explain why they don't apply.
- Code style: self-documenting code over comments, no logging unless for errors or security events,
anyhow::Resultfor error handling.
What to contribute:
- Bug fixes (link to an existing issue to show community need)
- Performance improvements
- New MCP extension integrations (in
crates/goose-mcp/) - UI improvements for the Electron desktop app (
ui/desktop/) - Documentation and examples
- Test improvements (prefer
crates/goose/tests/directory)
Tip: Run ./target/debug/goose configure after building to set up an LLM provider, then ./target/debug/goose session to try Goose before contributing.
4. AgentGateway · Production Rust Proxy
Why it's hardest: AgentGateway is a production-grade proxy with deep networking code (TLS, HTTP/2, gRPC, xDS), a CEL policy engine, and optional Kubernetes integration. It requires Rust edition 2024 (min rustc 1.90) and understanding of proxy architecture.
Setup:
git clone https://github.com/YOUR-USERNAME/agentgateway.git
cd agentgateway
# Build UI
cd ui && npm install && npm run build && cd ..
# Build gateway
export CARGO_NET_GIT_FETCH_WITH_CLI=true
make build
# Run
./target/release/agentgateway # UI at http://localhost:15000/ui
Quality gate before submitting:
make lint # cargo fmt + clippy
make test # all Rust tests
# If you touched UI:
cd ui && npm run lint && npm test
Contributing rules:
- Conventional Commits required
- Follow the Code of Conduct
- Add tests for new functionality
- Update docs for API/CLI/user-facing changes
- Formal governance: Technical Steering Committee (TSC) oversees all technical decisions
For Kubernetes development (optional):
Requires Kind, Tilt, ctlptl, cross, Docker, and Go 1.22+. See DEVELOPMENT.md for the Tilt-based local workflow.
What to contribute:
- Bug fixes (easiest path in)
- Documentation improvements
- New guardrail provider integrations
- OpenTelemetry trace/metric enhancements
- New MCP transport support
- Kubernetes deployment examples
- UI improvements
Tip: Use GitHub Codespaces. AgentGateway includes a .devcontainer.json for one-click development environments. Click Code → Create codespace on main and you're ready to go.
Get Involved
All four projects are actively developed and welcome contributors at every level, from typo fixes to protocol proposals.
| Project | Repo | Docs | Community |
|---|---|---|---|
| MCP | github.com/modelcontextprotocol | modelcontextprotocol.io | GitHub Discussions |
| Goose | github.com/aaif-goose/goose | goose-docs.ai | Discord |
| AGENTS.md | github.com/anthropics/agents.md | agents.md | GitHub Issues |
| AgentGateway | github.com/agentgateway/agentgateway | agentgateway.dev | Discord |
The AAIF is at aaif.io. If you're interested in the ambassador program, you can find details there.
The agentic AI ecosystem is being built right now, in the open. The projects above are the infrastructure layer: protocols, runtimes, gateways, conventions. They're not glamorous, but they're what makes agents actually work in production. If you care about that, pick a project, fork it, and start with something small.
Happy Learning! 🚀
Marco Gonzalez is a software engineer and AAIF Ambassador at the Linux Foundation. Find him on GitHub and LinkedIn.
Top comments (2)
Nice map — the four-layer framing (protocol / agent / convention / gateway) is the clearest I've seen for where the pieces actually sit. The MCP "build the server once, any agent uses it" pitch is real, but the thing I'd flag for anyone starting: the date-based spec moves fast, and auth (OAuth, plus the sampling flow where the server asks the client for completions) is where the production rough edges still are.
Honestly, the most leverage we've gotten is from the least glamorous layer — AGENTS.md. Sounds trivial, but one convention for "here's how to operate in this repo" is what keeps a fleet of agents from each reinventing context-gathering. One addition to the contribution list: writing a real MCP server for some niche internal tool teaches you the spec faster than reading it — it forces you into the gaps the toy examples skip (cancellation, partial results, long-running tools). Curious whether AgentGateway is converging on a standard way to do per-tool authz, since that's the question everyone hits the moment agents touch anything that mutates state.
Nice guide. Just a quick thanks; great reference to have --
appreciated 👍