agentgateway: The Data Plane for Agentic Traffic

TL;DR - agentgateway is an open-source Rust gateway that treats MCP tool calls, Agent-to-Agent messages, and LLM inference as first-class traffic, alongside ordinary HTTP and gRPC. Donated by Solo.io, it joined the Agentic AI Foundation in June 2026 as its fourth hosted project and the first addition since launch. If MCP and A2A define connectivity and goose executes agent work, agentgateway governs the resulting network traffic in production.

Updated August 27, 2026 to place agentgateway in AAIF's current five-project stack after A2A joined as the fifth project.

Here's a problem every team hits about a week after their agent prototype starts working.

The agent calls tools. It queries a model. It hands work to another agent. Conventional network tooling can observe the underlying HTTP traffic, but it often lacks the MCP and A2A semantics needed to identify which tool an agent invoked. Teams can build custom parsers and policies, but that adds operational work before they can rate limit a tool, attribute its cost, or express a rule such as "this agent may read from the CRM but never write to it."

The traffic is real, it's expensive, and it's invisible.

What agentgateway actually is#

agentgateway is an open-source gateway built for how AI systems actually route traffic. It provides a single operational layer for MCP traffic, Agent-to-Agent communication, LLM inference, REST APIs, and gRPC services.

It's written in Rust for low-latency, high-throughput proxying, and splits into a control plane and a proxy data plane. It runs on bare metal, virtual machines, containers, and Kubernetes.

   agents ---> +------------------------------+ ---> MCP servers / tools
   apps   ---> |        agentgateway          | ---> LLM providers
               |  policy - authz - observ.    | ---> REST / gRPC services
               |  Rust proxy + control plane  |
               +------------------------------+

What it adds on top of raw agent traffic#

• MCP virtualization - present many backing MCP servers as one surface, so agents see a stable endpoint while you reorganize what's behind it.
• Model-agnostic LLM routing - switch providers without touching application code.
• Tool-level access policies - authorize per tool, not per endpoint. A programmable gateway can approximate this with custom parsing; agentgateway makes MCP-aware tool identity a native policy surface.
• Prompt guards - inspect and block on request and response content.
• Rate limiting and budget controls - real cost attribution for token spend.
• Observability - traces that follow a request across the agent, tool, and model hops.

Why it joined AAIF, and why that matters#

The Agentic AI Foundation launched in December 2025 with three donated projects: MCP from Anthropic, goose from Block, and AGENTS.md from OpenAI. Those cover how agents use tools, how agents run, and how agents understand a codebase.

None of them covers what happens when that traffic hits production at scale. agentgateway's arrival in June 2026 filled that gap, and the sequencing is telling: the industry standardized the protocols first, then came back for the governance layer once real deployments made the need obvious.

It arrived with an established multi-organization contributor community. Moving under neutral governance formalized a project that already sat across vendors, runtimes, and infrastructure boundaries.

How it's governed#

agentgateway operates under a formal Technical Charter as part of LF Projects, LLC. The Technical Steering Committee is initially the project's Maintainers, and TSC meetings are intended to be open to the public. Roles follow the standard Linux Foundation split: Contributors, meaning anyone submitting code, documentation, or other artifacts, and Maintainers.

The charter states the mission plainly:

to create a secure, scalable, and standardized foundation for AI agents to discover, communicate with, and leverage external tools and services, enabling seamless cooperation between agents, models, and APIs across organizations and ecosystems.

Where it sits next to Kubernetes#

This is the part that matters if you already run cloud-native infrastructure.

kagent, a CNCF Sandbox project, runs AI agents inside Kubernetes as first-class objects and speaks MCP natively. agentgateway is the layer that governs the traffic those agents generate on the way out. One project puts agents in your cluster; the other makes their behaviour observable and enforceable.

That combination is the concrete link between the two foundations. CNCF supplies the runtime, AAIF supplies the standards, and agentgateway is where the two meet in the data path. For a platform team that already has Kubernetes, GitOps, and RBAC, agentgateway is the piece that extends those existing controls to cover agent traffic rather than asking you to invent a parallel governance story.

How to contribute#

agentgateway joined AAIF as its fourth project in June 2026. A2A became the fifth in August, but agentgateway remains the project's operational-control surface and an active place for contributors who want to work on agent traffic rather than another agent runtime.

• Rust core - proxy, control plane, protocol handling.
• UI - the web workspace, formatted and linted with Biome and tested through pnpm scripts.
• Protocol and API work - buf-generated API and schema definitions.
• Docs, examples, and architecture notes.

The gates: Rust changes run make lint and make test; UI changes run pnpm check:fix, pnpm lint, and pnpm test:e2e. New functionality needs tests. Commits follow Conventional Commits. The flow is fork, add an upstream remote, branch, rebase on upstream/main, then open a pull request.

For the full on-ramp across all five AAIF projects and the house rules each one enforces, see How to Contribute to AAIF. For foundation context, see What Is the Agentic AI Foundation.

Frequently asked#

What is agentgateway?#

agentgateway is an open-source gateway, written in Rust, that provides a unified policy, security, and observability layer for AI agent traffic: MCP tool calls, Agent-to-Agent messages, LLM inference, REST, and gRPC. It was donated by Solo.io and is now a hosted project of the Agentic AI Foundation.

When did agentgateway join the Agentic AI Foundation?#

June 2026. It was the fourth hosted project and the first added since AAIF launched in December 2025 with MCP, goose, and AGENTS.md.

How is agentgateway different from a normal API gateway?#

A conventional API gateway understands HTTP verbs and REST paths but has no concept of an MCP tool call or an agent-to-agent message. agentgateway adds tool-level access policies, MCP virtualization, model-agnostic LLM routing, prompt guards, and token budget controls, so agent traffic can be governed with the same rigour as ordinary API traffic.

Where does agentgateway run?#

On bare metal, virtual machines, containers, and Kubernetes. It splits into a control plane and a Rust proxy data plane.

References#

• agentgateway project site
• agentgateway architecture
• agentgateway repository
• A2A joins AAIF's open agentic stack

Written by Aman Mundra - Founder & CEO, Welzin · Co-founder & CEO, CogNerd · ex-PayPal ML.