# The Open Source Agentic AI Stack: What AAIF Projects Do and How to Contribute

> Source: <https://dev.to/mgonzalezo/the-open-source-agentic-ai-stack-what-aaif-projects-do-and-how-to-contribute-24be>
> Published: 2026-06-24 08:37:58+00:00

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](https://cashapp.github.io/hermit/) for reproducible tooling and [just](https://github.com/casey/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](https://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 components`pnpm run dev`

), `npm run build`

during development, it breaks HMR`npm run lint`

before submitting**What 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 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:**

`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
# If you changed server APIs:
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
# 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:**

**For Kubernetes development (optional):**

Requires Kind, Tilt, ctlptl, cross, Docker, and Go 1.22+. See [DEVELOPMENT.md](https://github.com/agentgateway/agentgateway/blob/main/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](https://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.*