agentgateway MCP gateway: secure and trace AI agent tools

agentgateway MCP gateway, open source: federate MCP servers, CEL rules per tool, JWT authentication and OpenTelemetry traces for every tool call.
agentgateway passerelle MCP : sécuriser et tracer les outils des agents IA

agentgateway MCP gateway: the agentgateway/agentgateway repository describes itself as a next-generation “agentic” proxy for AI agents and MCP servers. Written in Rust, it sits between an agent (Claude Code, Cursor, an in-house service) and the tools it calls, to federate them, authenticate callers, filter what is exposed and trace every tool call with OpenTelemetry. The repository page showed about 5,800 stars and 1,000 forks on 30 October 2026, under the Apache 2.0 licence.

For an SRE or a platform team, the question is not “do we need yet another proxy?” but “where do we put the control point when ten agents call thirty MCP servers?”. An agent that receives a server’s full tool list can call any of them; a gateway that filters that list by identity, logs the arguments and exports one span per tools/call brings those calls back into the usual scope of observability and security.

Honesty note: span.observer has not deployed agentgateway. Commands, excerpts and screenshots come from the README, the repository’s examples/ folder and the agentgateway.dev documentation.

agentgateway MCP gateway: what the repository says

  • Project and governance: the README states that agentgateway is a Linux Foundation project. The project blog dates the donation by Solo.io to the Linux Foundation to 25 August 2025, and the documentation landing page says the project was accepted as an Agentic AI Foundation (AAIF) project in 2026. We found no mention of the CNCF: do not present it as a CNCF project.
  • Licence and language: Apache 2.0, checked in the LICENSE file on 30 October 2026. The repository is a Cargo workspace (Rust, 2024 edition); the documented agentgateway --version output for 1.7.0 reports rust_version 1.89.0 and an x86_64-unknown-linux-musl target.
  • Version: the releases page lists v1.7.0 as the latest version, published on 27 October 2026, after v1.6.0 on 2 October. The project blog places 1.0.0 in March 2026: the cadence is monthly, with breaking changes documented in every minor release.
  • Scope: the README describes three roles: an LLM gateway (OpenAI-compatible API, budgets, guardrails), an MCP gateway (tool federation, stdio, HTTP, SSE and Streamable HTTP transports, OpenAPI exposed as tools, OAuth) and an A2A gateway. This article sticks to the MCP role, with authentication, CEL authorisation and telemetry.
  • Deployment modes: a standalone binary driven by a YAML file, or a Kubernetes controller implementing the Gateway API. Release 1.7.0 publishes the cr.agentgateway.dev/agentgateway:v1.7.0 image, the controller image and three Helm charts.

A tour of the configuration

An agentgateway configuration file is short. The repository’s mcp-authorization example fits in thirty lines and shows the whole chain: a listening port, a jwtAuth policy that validates client tokens, mcpAuthorization rules written in CEL, and an MCP target over HTTP.

config.yaml file from the mcp-authorization example in the agentgateway repository: jwtAuth policy with issuer, audiences and jwks, three mcpAuthorization rules in CEL and an MCP target on http://localhost:3001/mcp
Source : github.com

Three things to read in this file:

  • jwtAuth declares the issuer, the audiences and the location of the public keys; the README warns that the keys and tokens shipped in manifests/jwt/ are for demonstration only.
  • mcpAuthorization.rules holds CEL expressions evaluated against the MCP call, not the HTTP request: mcp.tool.name == "echo" allows everyone, jwt.sub == "test-user" && mcp.tool.name == "get-sum" reserves a tool for one user, and a third rule relies on a nested claim. According to the documentation, a tool that is not allowed disappears from the tools/list response and a direct call to it is denied.
  • Targets accept stdio (the gateway launches the command) or mcp with an HTTP host. Both forms mix in the same list.

With several targets, the gateway aggregates the servers into a single MCP endpoint and prefixes each tool with its target name to avoid collisions. The mcp-multiplex example exposes the time and everything servers this way:

Tool list seen in MCP Inspector through agentgateway, mcp-multiplex example from the repository: time_get_current_time, time_convert_time, everything_echo and everything_add, each tool prefixed with its target name
Source : raw.githubusercontent.com

The same README points out a concrete trap: if one target fails to start, initialize fails for the whole multiplexed backend. A broken MCP server therefore cuts access to all the others, which argues for an alert on the availability of each target.

Step-by-step installation (standalone mode)

Step 1 — Install the binary

The documentation offers an install script, with a pinned-version option that we recommend for anything beyond a trial:

curl -sL https://agentgateway.dev/install | bash -s -- --version v1.7.0
agentgateway --version

The binary lands in /usr/local/bin/agentgateway. Nightly builds exist for Linux (x86 and ARM), macOS and Windows, versioned 0.0.0-alpha.<commit>: keep them for testing.

Step 2 — Start a test MCP server

PORT=3005 npx -y @modelcontextprotocol/server-everything streamableHttp

Step 3 — Write the configuration

The MCP quickstart in the documentation also serves the web UI on the same port:

# yaml-language-server: $schema=https://agentgateway.dev/schema/config
gateways:
  default:
    port: 4000
mcp:
  targets:
  - name: server-everything
    mcp:
      host: http://localhost:3005/mcp
ui: {}
agentgateway -f config.yaml
# info  app  serving UI at http://localhost:4000/ui

Step 4 — Check with an MCP client

The UI offers a “Tool Playground”. On the command line, the quickstart chains initialize, tools/list and then tools/call as JSON-RPC against http://localhost:4000/mcp, with the mcp-session-id header returned at initialisation. The expected answer to an echo is Echo: <your message>.

Observing tool calls: metrics, logs, traces

This is the core of the interest for an SRE: according to the “MCP observability” documentation, the gateway produces all three signals with no instrumentation on the agent or the MCP server side.

Metrics. The Prometheus endpoint listens on localhost:15020/metrics. The reference lists agentgateway_mcp_requests_total, a counter labelled by server, method (tools/call, tools/list), resource and resource_type. Counters only appear after the first request. The README of the mcp-telemetry example shows an older output with tool_calls_total: check the names on your version before writing an alert.

Logs. Every request produces a structured line with mcp.method.name, mcp.target, mcp.session.id, gen_ai.tool.name, trace.id and span.id. An accessLog policy can add the arguments and result of a call:

frontendPolicies:
  accessLog:
    filter: 'mcp.methodName == "tools/call"'
    add:
      tool_args: 'mcp.tool.arguments'
      tool_result: 'mcp.tool.result'
      tool_error: 'mcp.tool.error'

Tool lists are written in full into each matching line: filter on the method to limit volume, as the documentation advises.

Traces. OTLP export is enabled with frontendPolicies.tracing, with a host (OTLP gRPC by default, protocol: http available) and randomSampling (true, or a fraction such as 0.1). The resources field sets service.name, which defaults to agentgateway; attributes adds attributes computed in CEL, remove drops some, and filter exports only the spans matching an expression. Spans carry mcp.method.name, mcp.target, mcp.session.id, gen_ai.tool.name, and mcp.error.code on failure; the span name follows the form <method> <target>_<tool>, for example tools/call everything_echo.

agentgateway frontendPolicies.tracing configuration excerpt with host localhost:4317, randomSampling and resources service.name, followed by the curl output on localhost:15020/metrics showing the tool call counters of the mcp-telemetry example
Source : agentgateway.dev

The repository’s mcp-telemetry example ships a docker-compose.yaml with an OpenTelemetry Collector (OTLP gRPC receiver on 4317) and a Jaeger; its screenshot shows a 560 ms server-side call_tool span.

Jaeger screenshot published in the mcp-telemetry example of the agentgateway repository: trace of a 560 ms call_tool, a single server span, attributes otel.scope.name and telemetry.sdk.language rust
Source : raw.githubusercontent.com

What about Dynatrace?

The project documents no Dynatrace integration; we claim nothing beyond what OTLP allows. On the agentgateway side, export is OTLP gRPC by default, with headers customisable through policies.requestHeaderModifier.set. On the Dynatrace side, the OTLP export documentation states that gRPC is not accepted: the API expects OTLP/HTTP on /api/v2/otlp (SaaS: https://{id}.live.dynatrace.com/api/v2/otlp; Managed: through an Environment ActiveGate on port 9999) and recommends a Collector to convert gRPC to HTTP. The safest path is therefore agentgateway → Collector (OTLP gRPC receiver, otlphttp exporter) → Dynatrace; see the Collector Contrib components. On SaaS, the gen_ai.tool.name and mcp.target attributes can be queried in DQL on spans; on Managed, traces land in Distributed traces without DQL or Grail. For the next step of the analysis, measuring the cost of an AI agent with OpenTelemetry and detecting MCP tool poisoning start from the same attributes.

Limits and open points

  • 1.7.0 introduces a breaking change: standalone mode now always encrypts MCP session IDs; sessions opened before the upgrade are rejected unless you set config.session.key: disabled. Plan the upgrade off-peak.
  • Authorisation rules and CEL guardrails (mcpGuardrails, kind: expression processors with reject or transform) are powerful but live in a YAML file: without review and testing (the project ships a “CEL playground” in the UI), a faulty expression denies or lets through more than intended.
  • Operational detail is spread across the documentation, the example READMEs and the release notes, which do not always name metrics the same way.
  • The quickstart leaves the web UI unauthenticated on the gateway port: do not reproduce this on a shared network. The documentation has a dedicated section for securing the UI.
  • Like any gateway, agentgateway becomes a single point of passage: its unavailability cuts off every tool for every agent.

Good practices

  • Pin the binary or image version and read the “breaking changes” section of every release before upgrading.
  • Write mcpAuthorization rules as an allow-list per tool and per identity; a tool missing from tools/list is your first line of defence.
  • Export traces to a Collector: you gain the gRPC → HTTP conversion, batching and a redaction point for mcp.tool.arguments if you log them.
  • Alert on agentgateway_mcp_requests_total per server: a stdio target that no longer starts shows up there first.
  • Pair the gateway with an isolated runtime for the agent itself: agent-sandbox fences the agent’s pod, agentgateway fences its outbound calls; the guardrails for AI agents in production cover content. To expose a Dynatrace environment to an agent, the Dynatrace MCP server is a natural candidate to place behind the gateway.

Frequently asked questions

Does agentgateway replace authentication on MCP servers?

It centralises it on the client side: jwtAuth, API keys or OIDC authenticate the agent, and backendAuth describes how the gateway authenticates to each target (passthrough, token, token exchange).

Which OpenTelemetry signals does the gateway emit for a tool call?

One span per MCP request with mcp.method.name, mcp.target, mcp.session.id and gen_ai.tool.name, a structured log line carrying the same fields plus trace.id, and the agentgateway_mcp_requests_total counter on :15020/metrics.

Can these traces be sent to Dynatrace?

Yes, over OTLP, but not directly in gRPC: the Dynatrace API only accepts OTLP/HTTP on /api/v2/otlp. Go through an OpenTelemetry Collector, or set protocol: http and the required authorisation header; we have not tested that second route.

Conclusion

agentgateway brings to teams running AI agents what an API gateway brought to microservices: a single point where you decide who calls what, and where every call leaves a span, a log line and a counter. The project is young, its release cadence is brisk and its breaking changes are real, but the telemetry documentation is at the level expected of an infrastructure component. Sources: agentgateway/agentgateway repository, MCP observability documentation and OTLP export to Dynatrace.

span.observer is an independent community blog, not affiliated with Dynatrace LLC or the projects mentioned. Trademarks belong to their owners. Tools change quickly: check commands and options in their official documentation.

Total
0
Shares
Leave a Reply

Your email address will not be published. Required fields are marked *

Previous Post
Syft générateur SBOM : inventorier vos images de conteneurs

Syft SBOM generator: inventory your container images

Next Post
OpenObserve, observabilité open source en Rust : logs, métriques, traces et RUM

OpenObserve open source observability in Rust: logs, metrics, traces and RUM

Related Posts