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.
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:
search_code
, execute_query
)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 | |
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 | |
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 | |
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:
Production features include:
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 | |
AAIF projects don't exist in isolation. Here are key open source projects in their orbit:
| Project | What It Does | Link |
|---|---|---|
| MCP TypeScript SDK | ||
| Build MCP clients/servers in TypeScript | ||
| 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 |
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 |
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:
.tsx
/.ts
) for new componentspnpm run dev
), npm run build
during development, it breaks HMRnpm run lint
before submittingWhat to contribute:
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/draft/schema.ts
(TypeScript → generates JSON Schema + MDX)docs/
, blog: Hugo in blog/
npm run format
for code formattingnpm run check:docs:links
to verify no broken linksAI 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:
docs/
)schema/[version]/examples/[TypeName]/
)blog/
)Tip: The MCP Inspector (npx @modelcontextprotocol/inspector
) is a great way to learn MCP interactively before contributing.
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
just generate-openapi
Contributing rules:
feat:
, fix:
, docs:
, etc.)anyhow::Result
for error handling.What to contribute:
crates/goose-mcp/
)ui/desktop/
)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.
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
cd ui && npm install && npm run build && cd ..
export CARGO_NET_GIT_FETCH_WITH_CLI=true
make build
./target/release/agentgateway # UI at http://localhost:15000/ui
Quality gate before submitting:
make lint # cargo fmt + clippy
make test # all Rust tests
cd ui && npm run lint && npm test
Contributing rules:
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:
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.
All four projects are actively developed and welcome contributors at every level, from typo fixes to protocol proposals.
| Project | Repo | Docs | Community |
|---|---|---|---|
| MCP | |||
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.