---
title: "Best MCP gateways: open-source and managed options compared"
description: "Compare the best MCP gateways, open source and managed: Bifrost, Docker, ContextForge, agentgateway, Kong, AgentCore, Azure, and more, by auth and tool access."
summary: "An MCP gateway gives AI agents one endpoint for many Model Context Protocol servers and enforces authentication, tool access, and audit logging in one place. This comparison checks ten open-source and managed gateways on transports, OAuth, tool filtering, token reduction, and license."
type: "comparison"
canonical_url: "https://theaiengineering.com/articles/best-mcp-gateways"
markdown_url: "https://theaiengineering.com/articles/best-mcp-gateways.md"
topic: "Model Context Protocol"
author: "The AI Engineering Editors"
publisher: "The AI Engineering"
published: "2026-11-18"
updated: "2026-11-18"
keywords: ["best mcp gateway","mcp gateway","mcp gateway open source","bifrost mcp"]
citation: "The AI Engineering Editors. \"Best MCP gateways: open-source and managed options compared.\" The AI Engineering, updated Nov 18, 2026. https://theaiengineering.com/articles/best-mcp-gateways"
---

# Best MCP gateways: open-source and managed options compared

## TL;DR

- An MCP gateway is a proxy that exposes many MCP servers to agents through one endpoint and centralizes authentication, tool filtering, and audit logging.
- The MCP authorization specification forbids a server from passing a client's token on to other services, so a gateway needs its own upstream credentials, either shared or issued per user.
- Bifrost, Docker MCP Gateway, Microsoft MCP Gateway, IBM ContextForge, and agentgateway are open source; AgentCore Gateway, Azure API Management, Prisma AIRS AI Gateway, and Cloudflare MCP server portals are commercial services.
- Seven of the ten gateways compared here also govern LLM traffic, and six also govern A2A agent traffic.
- Gateways shrink large tool sets in different ways: Bifrost and Cloudflare let the model write code against tools, AgentCore Gateway offers semantic tool search, and Docker can load servers on demand.

An MCP gateway is a proxy that gives AI agents one endpoint for many Model Context Protocol servers and enforces authentication, tool access, and logging in one place. The products range from a Docker CLI plugin on a laptop to managed services from AWS, Microsoft, and Cloudflare, so the best MCP gateway for a team depends on where its agents run, which identity provider it uses, and whether model and agent traffic need the same controls. This comparison sets out selection criteria, checks ten gateways against their official documentation as of November 2026, and maps them to common situations. More guides are in the [MCP topic hub](https://theaiengineering.com/topics/mcp).

## What is an MCP gateway?

An [MCP gateway](https://theaiengineering.com/glossary/mcp-gateway) is a proxy between MCP hosts and many [MCP servers](https://theaiengineering.com/glossary/mcp-server) that exposes them through one endpoint and applies shared authentication, tool policy, and audit logging.

To a host such as Claude Code or Cursor, the gateway looks like one server. Behind it, the gateway authenticates the caller, returns only the tools that caller may use, attaches a credential for each upstream server, and records each call. The [Model Context Protocol](https://theaiengineering.com/glossary/model-context-protocol) specification does not define gateways, but it anticipates intermediaries that aggregate servers and return different tool lists to different callers.

**Figure 1: Hosts see one endpoint; the gateway authenticates, filters, swaps credentials, and logs before routing each call.**

MCP hosts connect to one gateway endpoint, where requests pass four steps, authenticate, filter tools, attach credential, route and log, before reaching three upstream servers.

Components:

- **MCP hosts**: Claude Code · Cursor · custom agents
- **Authenticate**: OAuth 2.1 or API key
- **Filter tools**: per user or key
- **Attach credential**: shared or per user
- **Route and log**: audit trail
- **Local server**: stdio, in container
- **SaaS server**: Streamable HTTP
- **Internal REST API**: exposed as tools

Groups:

- MCP gateway: Authenticate, Filter tools, Attach credential, Route and log
- MCP servers: Local server, SaaS server, Internal REST API

Connections:

- MCP hosts → Authenticate
- Authenticate → Filter tools
- Filter tools → Attach credential
- Attach credential → Route and log
- Route and log → Local server
- Route and log → SaaS server
- Route and log → Internal REST API

For how the pattern works on the wire, read the gateway section of [what is the Model Context Protocol](https://theaiengineering.com/articles/what-is-model-context-protocol); for the same idea applied to model traffic, read [what is an AI gateway](https://theaiengineering.com/articles/what-is-an-ai-gateway).

## How to evaluate an MCP gateway

Evaluate an MCP gateway first on where it runs, which transports it speaks, how it authenticates callers and upstream servers, and how finely it filters tools. Then check its catalog, audit logging, approval flows, coverage of LLM and A2A traffic, token reduction for large tool sets, and license. The first four criteria decide fit; the rest decide how much policy you can enforce.

- **Deployment:** self-hosted binary, container, or Kubernetes workload, or a managed service that puts a vendor in the tool-call path.
- **Transports:** MCP defines stdio for local servers and Streamable HTTP for remote ones, and HTTP+SSE is deprecated (see [MCP transport](https://theaiengineering.com/glossary/mcp-transport)). Some gateways reach only remote HTTP servers.
- **Authentication:** for HTTP, the [MCP authorization specification](https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization) is based on OAuth 2.1, with Protected Resource Metadata (RFC 9728) and tokens bound to one server (RFC 8707). Upstream, per-user credentials let a tool act in the caller's own account.
- **Tool filtering:** a different tool list per user, team, or key, ideally deny-by-default and per tool rather than per server.
- **Catalog and audit logging:** a list of approved servers, plus a record of caller, tool, arguments, and result for each call.
- **Approval flows:** holding a call for [human-in-the-loop](https://theaiengineering.com/glossary/human-in-the-loop) approval, or auto-approving only listed tools.
- **LLM and A2A traffic:** an [AI gateway](https://theaiengineering.com/glossary/ai-gateway) that also proxies MCP and [A2A](https://theaiengineering.com/glossary/a2a-protocol) applies one set of keys and logs to model, tool, and agent calls.
- **Token reduction:** tool definitions fill the model's [context window](https://theaiengineering.com/glossary/context-window) on every request, so tool search or code execution against tools matters at hundreds of tools.
- **License:** open source, open core with an enterprise edition, or commercial.

### Per-user credentials and the no-passthrough rule

The specification's token rules shape how every gateway handles credentials. Servers must validate that each token was issued for them, and the authorization specification states that MCP servers "MUST NOT accept or transit any other tokens." To a host, a gateway is an MCP server, so it cannot forward the client's token upstream. It needs its own credential for each upstream server: a shared one set by an administrator, or a per-user one from a separate OAuth flow, as Figure 2 shows.

**Figure 2: With per-user OAuth, the gateway never forwards the agent's token; it obtains and stores a separate upstream token for each user.**

An agent calls a tool through the gateway, the user signs in to the upstream service once, and the gateway retries the call with a stored per-user token.

Steps:

1. Agent → MCP gateway: tools/call + token
2. MCP gateway → Agent: Upstream sign-in URL
3. Agent → Upstream OAuth: User approves
4. Upstream OAuth → MCP gateway: Per-user token
5. Agent → MCP gateway: tools/call retried
6. MCP gateway → Upstream server: Call as the user
7. Upstream server → MCP gateway: Tool result
8. MCP gateway → Agent: Result, logged

Shared credentials are simpler, but every user then acts as the same account in GitHub, Jira, or a database. Per-user credentials keep the upstream system's own permissions and audit trail, at the cost of one sign-in per user for each server.

## MCP gateways at a glance

The ten gateways fall into three groups: open-source projects you run yourself, API management platforms that add MCP to an existing gateway, and managed services. The table summarizes deployment, license, upstream server support, and the other traffic each one governs, based on official documentation as of November 2026.

| Gateway | Deployment | License | Upstream MCP servers | Also governs |
|---|---|---|---|---|
| Bifrost | Self-hosted | Apache 2.0; enterprise edition | STDIO, HTTP, SSE | LLM, A2A |
| Docker MCP Gateway | Laptop or Docker host | MIT | Containerized servers; remote HTTPS | MCP only |
| Microsoft MCP Gateway | Kubernetes | MIT | Servers it deploys to the cluster | MCP only |
| IBM ContextForge | PyPI, containers, Helm | Apache 2.0 | SSE, Streamable HTTP, WebSocket; REST, gRPC | A2A, LLM proxy |
| agentgateway | Binary, container, Kubernetes | Apache 2.0 | stdio, Streamable HTTP, OpenAPI | LLM, A2A |
| Kong AI Gateway | Self-hosted or Konnect | MCP plugins need Enterprise | Streamable HTTP; REST as tools | LLM, A2A |
| Azure API Management | Azure, self-hosted gateway | Commercial | Remote servers; REST as MCP | LLM, A2A |
| AgentCore Gateway | Managed on AWS | Commercial | MCP servers, Lambda, OpenAPI, Smithy | LLM, A2A |
| Prisma AIRS AI Gateway | Managed or self-hosted | Commercial; core MIT | Streamable HTTP | LLM |
| Cloudflare MCP server portals | Managed on Cloudflare | Commercial | Remote Streamable HTTP or SSE | MCP only |

## The 10 MCP gateways in detail

Each entry covers what the gateway is, its deployment and license, strengths, trade-offs, and best fit. Bifrost, Docker MCP Gateway, Microsoft MCP Gateway, IBM ContextForge, and agentgateway are open source; Kong and Azure API Management extend API gateways; and AgentCore Gateway, Prisma AIRS AI Gateway, and Cloudflare are sold as managed services.

### Bifrost

Bifrost is an open-source AI gateway from Maxim AI, written in Go, that runs an LLM gateway, an MCP gateway, and an agent gateway in one process. Its [MCP gateway](https://docs.getbifrost.ai/mcp/overview) connects to servers over STDIO, HTTP, or SSE and exposes their tools at one `/mcp` endpoint for clients such as Claude Code, Claude Desktop, and Cursor.

**Deployment and license:** Self-hosted with `npx -y @maximhq/bifrost` or Docker, under Apache 2.0; an enterprise edition adds access profiles, token exchange, and signed audit logs.

**Strengths:**

- **Tool filtering per [virtual key](https://theaiengineering.com/glossary/virtual-key).** Client configs expose no tools unless listed, request headers can narrow the set, and each key sets a ceiling headers cannot widen ([filtering docs](https://docs.getbifrost.ai/mcp/filtering)).
- **Authentication.** Clients send a virtual key or sign in through Bifrost's built-in [OAuth 2.1 server](https://docs.getbifrost.ai/mcp/gateway-auth). Upstream, it supports static headers, shared OAuth 2.0, and [per-user OAuth](https://docs.getbifrost.ai/mcp/auth/per-user-oauth).
- **Agent mode.** By default Bifrost returns tool calls to the application; [agent mode](https://docs.getbifrost.ai/mcp/agent-mode) runs tools listed in `tools_to_auto_execute` itself and returns the rest for approval.
- **Code Mode.** [Code Mode](https://docs.getbifrost.ai/mcp/code-mode) replaces tool definitions with four meta-tools, and the model writes a Python-like script that runs in a sandboxed Starlark interpreter. In Maxim AI's [published benchmark](https://github.com/maximhq/bifrost-benchmarking/blob/main/mcp-code-mode-benchmark/benchmark_report.md) of 508 tools across 16 servers, input tokens fell 92.8% with both modes passing 65 of 65 queries; test on your own workload.
- **Virtual MCPs and other traffic.** [Virtual MCPs](https://docs.getbifrost.ai/mcp/virtual-mcps), formerly MCP tool groups and now in open-source Bifrost, bundle selected tools into their own endpoint at `/mcp/<slug>`. The same keys govern model calls and, through the [Agent Gateway](https://docs.getbifrost.ai/features/agent-gateway/overview), A2A agents.

**Trade-offs:** You operate it. Code Mode runs only in the gateway, not the Go SDK, agent mode does not stream, and per-user OAuth needs HTTP connections. Token exchange and [signed audit logs](https://docs.getbifrost.ai/enterprise/audit-logs) are enterprise features.

**Best for:** One self-hosted gateway for model, MCP, and A2A traffic under the same keys, especially with large tool sets.

```bash
claude mcp add --transport http bifrost http://localhost:8080/mcp \
  --header "Authorization: Bearer <virtual-key>"
```

### Docker MCP Gateway

Docker MCP Gateway is an open-source proxy, shipped as the `docker mcp` CLI plugin, that runs each MCP server in an isolated container and exposes them through one connection. It powers the MCP Toolkit in Docker Desktop and also runs on Docker Engine or in Compose, per its [repository](https://github.com/docker/mcp-gateway).

**Deployment and license:** Local or any Docker host, under MIT. It serves one client over stdio by default, or several over HTTP. Docker's [documentation](https://docs.docker.com/ai/mcp-catalog-and-toolkit/mcp-gateway/) listed the gateway within Docker AI Governance as invite-only in November 2026.

**Strengths:**

- **Isolation.** Each server gets its own container, with 1 CPU and 2 GB of memory by default, and signature verification is on by default for Docker Hub `mcp/` images.
- **Secrets.** Secrets come from Docker Desktop or a `.env` file, and `--block-secrets`, on by default, stops them from passing to or from tools.
- **Catalog and allowlists.** The Docker MCP Catalog and shareable profiles define which servers run, flags enable individual tools, calls are logged by default, and an optional `dynamic-tools` feature loads servers only when an agent asks for them.

```bash
# Every tool from server1, and only tool2 from server2
docker mcp gateway run --servers server1,server2 --tools server1:* --tools server2:tool2
```

**Trade-offs:** HTTP transports authenticate every client with one shared bearer token, so the open-source gateway has no per-user identity. It does not govern model traffic.

**Best for:** Developers running local servers on laptops or in Compose.

### Microsoft MCP Gateway

Microsoft MCP Gateway is an open-source reverse proxy and management layer that deploys MCP servers to Kubernetes and routes each request to a ready instance. A control plane deploys servers as "adapters" and registers tools; the data plane serves each adapter at `/adapters/{name}/mcp` and a tool router at `/mcp`, per the [README](https://github.com/microsoft/mcp-gateway).

**Deployment and license:** Kubernetes, locally or on Azure, under MIT.

**Strengths:**

- **Stateless routing:** requests follow MCP 2026-07-28, so router instances scale without session affinity.
- **Lifecycle management:** deploy, update, and delete servers, read pod logs, and test servers in a built-in portal.
- **Entra ID roles:** app roles decide read and write access to each adapter and tool.

**Trade-offs:** The current version requires MCP 2026-07-28 clients, with no protocol downgrade. Authorization is tied to Entra ID, and the README does not describe per-user upstream OAuth.

**Best for:** Azure and Kubernetes teams hosting their own MCP servers behind Entra ID.

### IBM ContextForge

ContextForge is IBM's open-source registry and proxy that federates MCP servers, A2A agents, and REST or gRPC APIs behind one endpoint. It bundles selected tools into virtual servers and bridges stdio servers to HTTP with `mcpgateway.translate`, per its [README](https://github.com/IBM/mcp-context-forge).

**Deployment and license:** PyPI, a container image, or Helm, under Apache 2.0. Release 1.1.1 shipped on November 10, 2026.

**Strengths:**

- **Protocol breadth:** MCP, A2A, REST, and gRPC behind one gateway, over HTTP, WebSocket, SSE, and Streamable HTTP.
- **Identity:** JWT, SSO for GitHub, Google, Entra ID, Keycloak, Okta, and OIDC, RBAC, teams, and user-scoped upstream OAuth tokens.
- **Operations:** an admin UI, OpenTelemetry tracing, more than 40 plugins, and an optional OpenAI-compatible [LLM proxy](https://github.com/IBM/mcp-context-forge/blob/main/docs/docs/api/llm-proxy.md).

**Trade-offs:** The configuration reference lists more than 300 environment variables, scale-out needs Redis and a database, and arm64 is not supported in production.

**Best for:** Teams putting MCP servers, A2A agents, and REST or gRPC services behind one registry with SSO.

### agentgateway

agentgateway is an open-source Rust proxy for LLM, MCP, A2A, HTTP, and gRPC traffic in one data plane. It was donated to the Linux Foundation in 2025 and became an Agentic AI Foundation project in 2026, per its [introduction](https://agentgateway.dev/docs/standalone/latest/documentation/about/introduction/).

**Deployment and license:** Binary, container, or Kubernetes with the Gateway API, under Apache 2.0. Version 1.7.0 shipped on October 27, 2026.

**Strengths:**

- **Multiplexing:** a [Virtual MCP](https://agentgateway.dev/docs/standalone/latest/integrations/mcp/servers/virtual/) backend federates stdio, Streamable HTTP, and OpenAPI targets and prefixes tool names by target.
- **Authentication:** an OAuth resource server that serves Protected Resource Metadata, with guides for Auth0, Entra ID, Keycloak, Okta, and others.
- **Policy:** [MCP authorization](https://agentgateway.dev/docs/standalone/latest/documentation/mcp/mcp-authz/) rules are CEL expressions over MCP methods and JWT claims.

**Trade-offs:** Your team owns CEL policy. Backend auth covers API keys, passthrough, and cloud credentials; per-user upstream OAuth is not described.

**Best for:** Kubernetes platform teams wanting one Gateway API-native proxy for model, tool, and agent traffic.

### Kong AI Gateway

Kong AI Gateway adds AI plugins to Kong Gateway. The [AI MCP Proxy plugin](https://developer.konghq.com/plugins/ai-mcp-proxy/) proxies MCP servers, converts Kong-managed REST APIs into tools, or aggregates tools into one endpoint, and the [AI MCP OAuth2 plugin](https://developer.konghq.com/plugins/ai-mcp-oauth2/) validates tokens against an external authorization server.

**Deployment and license:** Self-hosted or Konnect. Kong Gateway is Apache 2.0, but both MCP plugins are part of AI Gateway Enterprise and require Kong Gateway 3.12 or later.

**Strengths:**

- **Plugin reuse:** Kong's authentication, rate-limiting, and logging plugins apply to MCP routes.
- **REST conversion:** existing APIs become MCP tools without new server code.
- **Registry and A2A:** an MCP Registry in Konnect Catalog (tech preview) and an A2A proxy plugin from Kong Gateway 3.14.

**Trade-offs:** Tool ACLs allow by default, the MCP plugin cannot share a route with other AI plugins except listed ones, and upstreams must be HTTP or HTTPS endpoints.

**Best for:** Kong Enterprise or Konnect customers.

### Azure API Management

Azure API Management (APIM) manages MCP servers as part of its AI gateway capabilities. It exposes managed REST APIs as MCP servers, with operations as tools, or puts existing remote MCP servers behind APIM policies, per its [MCP overview](https://learn.microsoft.com/en-us/azure/api-management/mcp-server-overview).

**Deployment and license:** Commercial; available in classic and v2 tiers (not Consumption) and the self-hosted gateway.

**Strengths:**

- **Policy reuse:** rate limits, quotas, JWT validation, IP filtering, and caching.
- **Authentication:** subscription keys or Entra ID tokens inbound, and credential manager OAuth tokens outbound ([security guide](https://learn.microsoft.com/en-us/azure/api-management/secure-mcp-servers)).
- **Breadth:** Azure API Center as a private MCP registry, and the same gateway governs LLM APIs and A2A agent APIs.

**Trade-offs:** APIM exposes MCP tools but not resources or prompts, does not support MCP in workspaces, and applies policies per server rather than per tool.

**Best for:** Existing APIM estates publishing internal REST APIs as MCP tools.

### Amazon Bedrock AgentCore Gateway

AgentCore Gateway is a fully managed AWS service that gives agents one endpoint for tools, agents, and models. Its MCP targets aggregate Lambda functions, API Gateway stages, OpenAPI and Smithy specs, remote MCP servers, and integrations such as Salesforce and Slack into one virtual MCP server, per the [AgentCore Gateway guide](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/gateway.html).

**Deployment and license:** Commercial, managed on AWS.

**Strengths:**

- **Authentication:** JWT from any identity provider or IAM inbound, with Protected Resource Metadata; outbound IAM, API keys, OAuth client credentials, three-legged OAuth, or on-behalf-of token exchange.
- **Semantic tool search:** the `x_amz_bedrock_agentcore_search` tool finds tools by natural-language query.
- **MCP features and more:** sessions, elicitation, sampling, and 2026-07-28 tasks, plus A2A passthrough and LLM routing across providers.

**Trade-offs:** AWS only. JWT subject claims land in CloudTrail, and AWS recommends token exchange over passthrough in production.

**Best for:** AWS-native teams turning Lambda functions and APIs into MCP tools.

### Prisma AIRS AI Gateway (formerly Portkey)

Prisma AIRS AI Gateway is the gateway Palo Alto Networks [acquired as Portkey](https://www.paloaltonetworks.com/company/press/2026/palo-alto-networks-completes-acquisition-of-portkey-to-secure-ai-agents) on May 29, 2026. Its [MCP gateway](https://portkey.ai/docs/aigw/product/mcp-gateway) sits between MCP clients and servers to handle authentication, access control, and logging.

**Deployment and license:** Managed or self-hosted; the core gateway is MIT-licensed, so check which MCP features your plan includes.

**Strengths:**

- **Registry:** an organization MCP registry with workspace grants, and a registry API (beta) that serves `server.json` entries.
- **Access:** per-workspace and per-user tool toggles, and rate limits per key, server, or tool.
- **Credentials and logs:** one sign-in by API key or OAuth 2.1, injected upstream credentials, per-call logs, and approval workflows per server.

**Trade-offs:** Upstream servers must use Streamable HTTP, so stdio servers have to be exposed over HTTP first.

**Best for:** Palo Alto Networks customers governing model and MCP traffic in one gateway.

### Cloudflare MCP server portals

Cloudflare MCP server portals, part of Cloudflare One, put several MCP servers behind one HTTP endpoint governed by Cloudflare Access policies. They became [generally available](https://developers.cloudflare.com/changelog/post/2026-09-24-mcp-portals-ga/) to all customers on September 24, 2026.

**Deployment and license:** Commercial, managed on Cloudflare's network.

**Strengths:**

- **Identity:** Access sign-in with your identity provider, OAuth for non-browser clients, service tokens for machines, and per-user upstream auth by default.
- **Tool controls:** disable tools or prompts, use an allowlist mode, and override tool names and descriptions.
- **Code Mode:** [portal Code Mode](https://developers.cloudflare.com/cloudflare-one/access-controls/ai-controls/mcp-portals/) collapses tools into search and code execution, running agent-written JavaScript in an isolated Dynamic Worker.

**Trade-offs:** Portals reach only remote HTTP servers, hold up to 120 servers each, and time out tool calls after 60 seconds. Logpush export needs an Enterprise plan.

**Best for:** Cloudflare One customers giving employees governed access to SaaS and internal servers.

## Feature comparison

Beyond deployment, the gateways differ most in client authentication, per-user upstream credentials, tool filtering, catalogs, and token reduction. In the table, "not documented" means the official documentation reviewed in November 2026 did not describe the feature.

| Gateway | Client auth | Per-user upstream credentials | Tool filtering | Catalog | Token reduction |
|---|---|---|---|---|---|
| Bifrost | Virtual key or OAuth 2.1 | Yes | Per client, request, and key | Virtual MCPs | Code Mode |
| Docker MCP Gateway | One bearer token | Not documented | Per tool | Docker MCP Catalog | On-demand servers |
| Microsoft MCP Gateway | Entra ID | Not documented | Per adapter and tool role | Adapter registry | Not documented |
| IBM ContextForge | JWT, SSO | Yes | Virtual servers, RBAC | YAML catalog | TOON compression |
| agentgateway | OAuth, JWT | Not documented | CEL rules | Not documented | Not documented |
| Kong AI Gateway | OAuth2 plugin | Not documented | Tool ACLs | MCP Registry (preview) | Not documented |
| Azure API Management | Keys, Entra ID | Credential manager | Per server | API Center | Not documented |
| AgentCore Gateway | JWT, IAM | Yes | Policy engine | Integrations | Semantic search |
| Prisma AIRS AI Gateway | API key, OAuth 2.1 | Injected per server | Per workspace and user | Org registry | Not documented |
| Cloudflare MCP server portals | Access, OAuth | Yes, by default | Per tool | Portal list | Code Mode |

## How to choose an MCP gateway

Start from where your agents and servers already run. Developer laptops favor local, container-based gateways; Kubernetes platform teams favor self-hosted proxies with policy in configuration; AWS-native teams favor AgentCore Gateway; and organizations with Kong or Azure API Management usually extend that estate before adding another proxy.

| Situation | Start with |
|---|---|
| Developer laptops with local stdio servers | Docker MCP Gateway, or Bifrost when the laptop also routes model calls |
| Kubernetes platform team | agentgateway, Bifrost, or IBM ContextForge; Microsoft MCP Gateway on Azure with Entra ID |
| AWS-native agents and Lambda tools | Amazon Bedrock AgentCore Gateway |
| Existing Kong Enterprise or Konnect | Kong AI Gateway |
| Existing Azure API Management | Azure API Management |
| Cloudflare One or Palo Alto Networks customers | Cloudflare MCP server portals or Prisma AIRS AI Gateway |
| Hundreds of tools per agent | Bifrost, Cloudflare, or AgentCore Gateway |

Pilot two candidates before committing. Connect the hosts your teams use, check that a filtered tool disappears from `tools/list` for a restricted caller, run one per-user OAuth flow against a SaaS server, and measure input tokens with your real tool set.

## What an MCP gateway does not solve

An MCP gateway controls which tools a caller reaches and with which credentials, but it does not make a tool safe. Tool descriptions and results still enter the model's context, the gateway concentrates upstream credentials in one place, and every agent depends on it. Plan for these risks before production traffic moves.

- **[Tool poisoning](https://theaiengineering.com/glossary/tool-poisoning):** pin approved tool definitions and alert when one changes.
- **[Prompt injection](https://theaiengineering.com/glossary/prompt-injection) through results:** treat tool output as untrusted input in the host.
- **Credentials and availability:** keep tokens in a secret manager, restrict admin access, and run replicas with health checks.

To build a server to put behind a gateway, follow [how to build an MCP server](https://theaiengineering.com/articles/how-to-build-an-mcp-server); for agent-to-agent traffic, read [A2A vs MCP](https://theaiengineering.com/articles/a2a-vs-mcp).

The [MCP platforms directory](https://theaiengineering.com/platforms/mcp-platforms) and the [AI gateways directory](https://theaiengineering.com/platforms/ai-gateways) list more options.

## Frequently asked questions

### What is the best MCP gateway?

No single MCP gateway fits every team. Self-hosted platform teams usually compare Bifrost, agentgateway, IBM ContextForge, and Microsoft MCP Gateway. Developers running local servers often start with Docker MCP Gateway, AWS teams evaluate AgentCore Gateway, and organizations already on Kong or Azure API Management extend those gateways. Shortlist by deployment, authentication, and tool filtering, then test two candidates.

### Is there an open source MCP gateway?

Yes. Bifrost, agentgateway, and IBM ContextForge are open source under Apache 2.0, and Docker MCP Gateway and Microsoft MCP Gateway are open source under MIT. All five can be self-hosted. Kong Gateway is open source, but its MCP plugins are part of Kong's AI Gateway Enterprise offering.

### Does Bifrost support MCP?

Yes. Bifrost connects to MCP servers over STDIO, HTTP, or SSE and exposes their tools at one /mcp endpoint for clients such as Claude Code, Claude Desktop, and Cursor. It filters tools per virtual key, supports shared and per-user OAuth to upstream servers, offers an agent mode with configurable auto-approval, and includes Code Mode for large tool sets.

### What is the difference between an MCP gateway and an MCP server?

An MCP server implements tools, resources, or prompts for a system such as a database or a code host. An MCP gateway implements few or no tools of its own. It looks like one server to the host, aggregates many servers behind one endpoint, and applies authentication, tool filtering, and logging before forwarding each call.

### What is the difference between an MCP gateway and an AI gateway?

An AI gateway governs traffic from applications to model providers, with token budgets, routing, and caching. An MCP gateway governs traffic from agents to tools, with tool allowlists and a credential for each backend server. Bifrost, agentgateway, Kong AI Gateway, and Azure API Management do both in one proxy.

### Do I need an MCP gateway for Claude Code or Cursor?

A single developer with a few servers can configure them directly in Claude Code or Cursor. A gateway helps once several people share servers, credentials need central storage, security teams want an allowlist of approved tools and an audit log, or client configurations start to drift. Both clients connect to a gateway like any other MCP server.

## Terms in this guide

- [MCP gateway](https://theaiengineering.com/glossary/mcp-gateway): An MCP gateway is a proxy that sits between MCP hosts and many MCP servers, exposing them through one endpoint and centralizing authentication, tool access policy, and audit logging.
- [MCP server](https://theaiengineering.com/glossary/mcp-server): An MCP server is a program that exposes tools, resources, and prompts to AI applications through the Model Context Protocol, running locally over stdio or remotely over Streamable HTTP.
- [Model Context Protocol (MCP)](https://theaiengineering.com/glossary/model-context-protocol): Model Context Protocol (MCP) is an open protocol, introduced by Anthropic in November 2024, that standardizes how AI applications connect to external tools, data sources, and prompts through MCP servers.
- [MCP transport](https://theaiengineering.com/glossary/mcp-transport): An MCP transport is the binding that carries Model Context Protocol messages between a client and a server; the specification defines stdio for local subprocesses and Streamable HTTP for remote servers.
- [Human-in-the-loop](https://theaiengineering.com/glossary/human-in-the-loop): Human-in-the-loop (HITL) is an agent design in which the run pauses at defined checkpoints, such as before a sensitive tool call, so a person can approve, edit, or reject the action.
- [AI gateway](https://theaiengineering.com/glossary/ai-gateway): An AI gateway is a proxy layer between applications and model providers that exposes one API for many models and centralizes routing, failover, access control, cost tracking, caching, and logging.
- [A2A protocol](https://theaiengineering.com/glossary/a2a-protocol): The A2A (Agent2Agent) protocol is an open standard, introduced by Google in April 2025, that lets AI agents built on different frameworks discover each other, exchange messages, and delegate tasks.
- [Context window](https://theaiengineering.com/glossary/context-window): A context window is the maximum number of tokens a language model can take into account in a single request, including the system prompt, conversation history, tool results, and the generated output.
- [Virtual key](https://theaiengineering.com/glossary/virtual-key): A virtual key is an API key issued by an AI gateway that maps a caller to its allowed models, budget, and rate limits, while the gateway keeps the real provider credentials.
- [Tool poisoning](https://theaiengineering.com/glossary/tool-poisoning): Tool poisoning is an attack in which a malicious or compromised MCP server hides instructions in a tool's description or schema, which the model reads as trusted context and may follow.
- [Prompt injection](https://theaiengineering.com/glossary/prompt-injection): Prompt injection is an attack in which text supplied to a large language model, typed by a user or hidden in content the model reads, alters the application's intended behavior or output.

## Related guides

- [What is the Model Context Protocol (MCP)? How it works](https://theaiengineering.com/articles/what-is-model-context-protocol): The Model Context Protocol (MCP) is an open standard for connecting AI apps to tools and data. Learn its architecture, transports, tool calls, and security.
- [How to build an MCP server: a Python and TypeScript tutorial](https://theaiengineering.com/articles/how-to-build-an-mcp-server): Learn how to build an MCP server with the official Python and TypeScript SDKs: tools, resources, transports, testing, client config, and production security.
- [What is an AI gateway? How it works and when you need one](https://theaiengineering.com/articles/what-is-an-ai-gateway): An AI gateway is a proxy between your apps and model providers. Learn how it works, its core features, AI gateway vs API gateway, and open source options.
- [A2A protocol vs MCP: differences and when to use each](https://theaiengineering.com/articles/a2a-vs-mcp): A2A protocol vs MCP: A2A connects AI agents to other agents, and MCP connects an agent to tools and data. Compare agent cards, tasks, transports, and security.

Part of the [Model Context Protocol](https://theaiengineering.com/topics/mcp) topic hub.

## Cite this guide

The AI Engineering Editors. "Best MCP gateways: open-source and managed options compared." The AI Engineering, updated Nov 18, 2026. https://theaiengineering.com/articles/best-mcp-gateways

- Title: Best MCP gateways: open-source and managed options compared
- Author: The AI Engineering Editors
- Publisher: The AI Engineering
- Published: 2026-11-18
- Updated: 2026-11-18
- URL: https://theaiengineering.com/articles/best-mcp-gateways
- Markdown: https://theaiengineering.com/articles/best-mcp-gateways.md

To cite one section, link to its anchor:

- [What is an MCP gateway?](https://theaiengineering.com/articles/best-mcp-gateways#what-is-an-mcp-gateway)
- [How to evaluate an MCP gateway](https://theaiengineering.com/articles/best-mcp-gateways#how-to-evaluate-an-mcp-gateway)
- [MCP gateways at a glance](https://theaiengineering.com/articles/best-mcp-gateways#mcp-gateways-at-a-glance)
- [The 10 MCP gateways in detail](https://theaiengineering.com/articles/best-mcp-gateways#the-10-mcp-gateways-in-detail)
- [Feature comparison](https://theaiengineering.com/articles/best-mcp-gateways#feature-comparison)
- [How to choose an MCP gateway](https://theaiengineering.com/articles/best-mcp-gateways#how-to-choose-an-mcp-gateway)
- [What an MCP gateway does not solve](https://theaiengineering.com/articles/best-mcp-gateways#what-an-mcp-gateway-does-not-solve)
- [Frequently asked questions](https://theaiengineering.com/articles/best-mcp-gateways#faq)
