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
  • MCP: The Protocol
  • Goose: The Agent
  • AGENTS.md: The Convention
  • AgentGateway: The Infrastructure
• How They Work Together
• Connected Open Source Projects
• Contributing: Where to Start
  • Difficulty Ranking
  • AGENTS.md · Easiest Entry Point
  • MCP Specification · Docs and Schema
  • Goose · Rust Agent Framework
  • AgentGateway · Production Rust Proxy
• 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.

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.

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.

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:

1. 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.
2. MCP Gateway: Connects agents to tools via MCP with tool federation, multi-transport support, OpenAPI integration, and OAuth authentication.
3. 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.

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

Agent & Infrastructure Ecosystem

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:

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 run npm run build during development, it breaks HMR
• Co-locate component styles with components
• Run npm run lint before 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 in blog/
• Date-based spec versioning (YYYY-MM-DD), NOT semver
• npm run format for code formatting
• npm run check:docs:links to 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::Result for 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.

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.