MCP gateways are a new product category, and the label now covers everything from a thin reverse proxy to a full policy, identity and audit plane for AI agent tool use. Identity providers, API gateway vendors, AI security start-ups, cloud platforms and open-source projects all ship something called an MCP gateway, and their capabilities differ far more than their marketing suggests. This vendor-neutral buyer's guide explains what the category does, when you actually need one, which capabilities are must-haves, how to evaluate products against the Model Context Protocol (MCP) specification, and how to run a proof of concept that tests real risks. It is written for security architects, platform engineering and identity teams preparing a shortlist or an RFP. The operating model around approval, registries and allowlists is covered in the MCP Gateway and MCP Server Governance Guide; this page focuses on choosing a product.
Key takeaways
- Define the job before the product. A gateway for remote SaaS MCP servers, a gateway for internally built servers and a control for local stdio servers on laptops are different problems, and few products solve all three.
- Specification conformance is the first filter. The MCP authorisation specification (revision 2025-11-25) requires audience-bound tokens, RFC 9728 protected resource metadata and RFC 8707 resource indicators, and forbids token passthrough. A gateway that forwards the caller's token downstream fails on day one.
- Enforce at the tool call, not just the connection. The value of a gateway is per-tool allow and deny, argument inspection, approval for destructive actions and a log of every call attributed to a user and an agent.
- The gateway becomes a credential vault. It holds downstream OAuth tokens and keys for every connected system, so the vendor's own security, default configuration and failure behaviour weigh as much as features.
- Test with your servers and hostile inputs. A useful proof of concept changes a tool definition after approval, sends an expired or wrong-audience token, injects instructions through a tool result and measures revocation time.
What the category does
An MCP gateway sits between MCP clients (IDEs, desktop assistants, agent runtimes) and MCP servers. Clients connect to one endpoint; the gateway authenticates the caller, decides which servers and tools that caller may see, forwards permitted calls to the right upstream server with a credential the gateway obtained for that server, and records what happened. Some products also run local servers in containers, publish an internal catalogue, or scan tool descriptions for injected instructions.
Products currently arrive from five directions, and the origin usually predicts strengths and gaps:
| Origin | Typical strengths | Typical gaps to probe |
|---|---|---|
| API gateway or service mesh extended to MCP | Throughput, TLS, rate limiting, mature operations, existing deployment in your estate | Understanding of MCP semantics (tools/list, tools/call, list_changed), per-tool policy, agent attribution |
| Identity provider or access management vendor | OAuth authorisation server, token exchange, user and agent identity, consent | Traffic inspection, tool filtering, coverage of local stdio servers |
| AI gateway or LLM proxy adding MCP routes | Model routing, cost controls, prompt and response logging | Authorisation depth, default credentials, separation of admin and data planes |
| AI or agent security specialist | Tool poisoning detection, behavioural monitoring, discovery of shadow servers | Production scale, high availability, standards-based identity |
| Open-source gateway or cloud-native service | Transparency, no licence cost, control over hosting | Support, hardening defaults, patch cadence, your own engineering effort |
None of these is wrong. The point is to map products to the job, then test the gaps their origin suggests.
Define requirements: when you need it
You probably need a gateway when one or more of the following is true. Write down which apply, the platforms involved and who owns them before contacting vendors.
- Several teams use remote MCP servers: developers and business users connect SaaS vendors' MCP endpoints with personal OAuth grants, and nobody can say which servers are in use or which scopes were granted.
- You are building internal MCP servers: each team is reimplementing authentication, logging and rate limiting, often badly. A gateway can provide those once, if it implements the specification correctly.
- Agents act for users against sensitive systems: code repositories, CRM, email, ticketing or production databases. You need per-tool policy and an audit trail that names both the user and the agent.
- Regulators or auditors ask what agents did: you need tool call records with arguments, outcomes and identities, retained like other security logs. See the AI Agent Audit Trails for Regulators Guide.
- You have had, or fear, a malicious or changed server: the postmark-mcp malicious MCP server worked normally for fifteen releases before one added line copied every email to an attacker. Version pinning and change detection matter.
You may not need a dedicated product yet if MCP use is limited to a few developers on local, read-only servers. Managed client configuration (allowlists of exact commands and URLs) and endpoint controls may be enough, with a gateway added when remote servers or agent-to-production access arrive. Small organisations can often start with an existing API gateway or identity provider feature and a tool allowlist; large organisations with many agent platforms usually need a dedicated policy point and central logging.
Must-have capabilities
These are the capabilities without which a product should not reach the shortlist, whatever else it does.
- Standards-based inbound authentication: the gateway acts as an OAuth 2.1 resource server, publishes protected resource metadata (RFC 9728) at a well-known URI or via the
WWW-Authenticateheader, validates that every token was issued for it as the audience, returns HTTP 401 for invalid or expired tokens and 403 withinsufficient_scopefor missing scopes, and never accepts tokens in the query string. - No token passthrough: the MCP specification states that servers must not pass through the token received from the client to upstream APIs. The gateway must obtain its own downstream token per upstream server (for example through token exchange or a separate OAuth grant) and keep the user and agent identity attached.
- Per-server and per-tool policy: allow or deny by server, tool name and caller, with tools filtered out of
tools/listresponses so the model never sees them. Policy should be able to classify tools as read, write or destructive. - Tool definition pinning and change detection: record the approved tool names, descriptions and input schemas, alert or block on
notifications/tools/list_changedor any difference at the nexttools/list, and require re-approval. The specification tells clients to treat tool annotations as untrusted unless they come from trusted servers, so areadOnlyHintis a claim, not a control. - Human approval hooks: the tools specification says there should always be a human in the loop able to deny tool invocations. The gateway should support approval for chosen tools or argument patterns, with the decision logged.
- Complete, exportable tool call logging: timestamp, user, agent or client ID, server, tool, arguments (with redaction rules), result status, policy decision and correlation IDs, streamed to your SIEM in a documented format.
- Secure credential custody: downstream tokens and keys encrypted at rest, held in or brokered from your secrets manager or a hardware-backed store, scoped per user where the upstream supports it, and revocable individually.
- Egress and SSRF protection: the security best practices document describes malicious servers pointing OAuth discovery URLs at internal addresses and cloud metadata (169.254.169.254). The gateway should block private, loopback and link-local ranges for discovery and upstream calls unless explicitly allowed.
- Secure session handling: non-deterministic session IDs, sessions never used as authentication, and session data bound to the authenticated user, as the best practices document requires.
Evaluation criteria
Use this table as the scoring sheet. Weight the first four rows most heavily: they are where products differ in ways that matter after an incident.
| Area | What good looks like | Evidence to request | Framework anchor |
|---|---|---|---|
| Authorisation conformance | Audience validation, RFC 8707 resource parameter, PKCE with S256, refresh token rotation for public clients, Client ID Metadata Documents or pre-registration supported | Conformance test results; a captured token showing the aud claim downstream | NIST SP 800-53 IA-9, AC-3 |
| Identity attribution | Downstream systems and logs see both the user and the agent; no shared service credential for all users | Sample log line and downstream audit record for one call | NIST CSF 2.0 PR.AA-05 |
| Tool policy depth | Per-tool allow and deny, argument rules, approval workflow, filtering in tools/list | Live demonstration with your servers | NIST SP 800-53 AC-6, CM-7; OWASP LLM06 Excessive Agency |
| Change and supply chain control | Pinned versions and tool definitions, diff on change, internal catalogue with owners | Demonstration of a changed description being blocked | NIST CSF 2.0 GV.SC-06; OWASP LLM03 Supply Chain |
| Content inspection | Scanning of tool descriptions and results for injected instructions and secrets, with measured false positive rates | Test corpus results; how detections are tuned | OWASP LLM01 Prompt Injection |
| Logging and detection | Structured events, SIEM integration, retention controls, redaction | Event schema; SIEM connector documentation | NIST SP 800-53 AU-2, AU-12; CSF 2.0 PR.PS-04, DE.CM-09 |
| Network and boundary | Private deployment option, egress allowlists, SSRF protection, mTLS to upstreams | Architecture diagram; network policy examples | NIST SP 800-53 SC-7 |
| Coverage of local servers | Containerised execution of stdio servers or integration with managed client policy on endpoints | Which clients are supported today, not on the roadmap | NIST SP 800-53 CM-7 |
| Resilience and performance | Documented fail-closed option, high availability, added latency per call measured under load | Benchmark under your traffic profile | Operational fit |
| Vendor security | No default admin keys, separate admin and data planes, independent testing, published vulnerability disclosure process | Penetration test summary, security advisories history | NIST SP 800-53 SA-9 |
Questions to ask vendors
- Show us the token your gateway sends to an upstream MCP server on behalf of a user. Which audience does it carry, who issued it, and how does the upstream know which agent made the call?
- How do you prevent token passthrough when an upstream server only supports static API keys? Where is that key stored, who can read it, and is it shared across users?
- Which revision of the MCP specification do you implement today, and how quickly did you adopt the last revision? What breaks when the next one changes the authorisation flow?
- What happens when a server sends
notifications/tools/list_changedor returns a changed tool description? Demonstrate the alert and the re-approval flow. - Can policy decide on tool arguments, for example blocking a repository write to a protected branch or an email to an external domain?
- Which detections do you run on tool results for injected instructions, and what are your measured false positive and false negative rates on a corpus we supply?
- If your gateway is unavailable, do calls fail open or closed, and can we choose per server?
- How do we revoke every credential and session for one user, one agent or one upstream server, and how long does it take end to end?
- Does your product ship with any default administrator key, password or open management port? How is the admin plane authenticated and separated from the data plane?
- Where are tool call logs, prompts and arguments processed and stored, for how long, and are they ever used to train models?
- How do you handle local stdio servers on developer machines: run them in your containers, integrate with client managed settings, or not at all?
- What security vulnerabilities have been reported in your product, and how quickly were they fixed and disclosed?
Red flags
- Passthrough by design: the gateway forwards the caller's bearer token unchanged, or exchanges every user for one shared service credential downstream.
- Authentication that fails open: the LiteLLM MCP auth bypass granted an unrestricted identity when token validation failed, and researchers found deployments still accepting a default master key. Ask how invalid tokens are handled and test it.
- Default secrets or open admin ports: any product that ships with a known key or an unauthenticated console, even if documentation says to change it.
- Prompt filtering presented as authorisation: classifiers on tool results are useful, but they do not replace per-tool policy and scoped credentials.
- Connection logs only: logs that show a session was opened but not which tools were called with which arguments.
- Hosted multi-tenant credential storage without isolation detail: the Smithery.ai MCP hosting breach showed a single platform token controlling thousands of hosted servers. Ask how one customer's keys are isolated from another's and from the vendor's build system.
- Roadmap presented as product: support for the current specification revision, local servers or argument policy described as "coming soon".
Deployment and integration
- Inventory first: list MCP clients, servers (local, remote vendor-hosted, third-party hosted, internal) and current credentials. The gateway is only as useful as the share of traffic forced through it.
- Connect identity: integrate the gateway with your identity provider as the authorisation server for inbound tokens, and register agents as distinct clients so attribution works from the first day. See the MCP Authorisation Specification Guide.
- Move credentials: replace static keys held in client configuration with gateway-brokered credentials stored in your secrets manager. See the Secrets Management Guide.
- Start in monitor mode: route one team's remote servers through the gateway with logging and policy evaluation but without blocking, for two to four weeks, to build the tool baseline and catch false positives.
- Enforce in rings: turn on deny for unapproved servers and destructive tools for the pilot team, then expand by business unit. Keep a documented bypass route (direct client configuration for named servers) that can be re-enabled if the gateway fails, and decide in advance which servers fail closed.
- Close the bypass: once coverage is complete, use managed client settings and egress controls so clients can reach remote MCP servers only through the gateway.
- Wire up detection: send tool call events to the SIEM and build alerts for unapproved servers, tool definition changes, spikes in destructive calls and calls from unknown agents. See the Agent Controls and Monitoring Guide.
Measure success with a few numbers: percentage of MCP traffic routed through the gateway; number of servers with a named owner and pinned version; percentage of upstream calls using per-user, audience-bound credentials rather than shared keys; time to revoke one agent's access everywhere; and number of tool definition changes detected and reviewed per month.
Proof of concept
- Choose three real servers: one vendor-hosted remote server with OAuth, one internal server, and one local stdio server, ideally including one with write or destructive tools.
- Set success criteria in writing: conformance to the authorisation specification, per-tool policy, attribution in downstream logs, added latency at expected load, revocation time and developer effort to onboard a server.
- Run negative token tests: send an expired token, a token for another audience, a malformed token and no token. Every one should receive 401, and none should reach an upstream server.
- Change a tool after approval: modify a tool description and input schema on your test server and confirm the gateway detects and blocks the change until re-approved.
- Inject through a result: return a tool result containing instructions to call another tool or send data elsewhere, and check whether the gateway flags it and whether policy stops the follow-on call.
- Test SSRF and egress: point a test server's resource metadata at an internal address and a cloud metadata address, and confirm the gateway refuses to follow it.
- Fail the gateway: stop the gateway mid-session and observe client behaviour against your fail-open or fail-closed decision.
- Revoke and time it: revoke one agent and one user, and measure how long until every upstream call fails.
Buyer checklist
- Use cases, server types and owning teams documented before vendor contact.
- Shortlist limited to products that pass audience validation and no-passthrough tests.
- Per-tool policy, tool definition pinning and approval hooks demonstrated on your own servers.
- Tool call log schema reviewed by the SOC and tested in your SIEM.
- Credential custody, isolation and revocation explained and timed.
- Default credentials, admin plane security and vulnerability history checked.
- Fail-open or fail-closed behaviour decided per server and tested.
- Rollout plan with monitor mode, enforcement rings, rollback route and coverage metrics agreed.
Standards and references
- Model Context Protocol: Authorization specification (2025-11-25)
- Model Context Protocol: Security Best Practices
- Model Context Protocol: Tools specification
- Model Context Protocol: The MCP Registry
- IETF: RFC 9728 OAuth 2.0 Protected Resource Metadata
- IETF: RFC 8707 Resource Indicators for OAuth 2.0
- OWASP GenAI Security Project: A Practical Guide for Securely Using Third-Party MCP Servers
- OWASP: Top 10 for LLM Applications 2025
How NHI Mgmt Group can help
We provide independent market analysis, RFP strategy and evaluation support for NHI and agentic AI identity programmes, including MCP gateway selection. Browse vendors in our NHI and AI products directory or contact us about independent evaluation support.
Related NHI Mgmt Group resources: MCP Gateway and MCP Server Governance Guide · MCP Security Guide · AI Gateway and LLM Gateway Guide · AI Agent Identity Security Buyer's Guide · MCP Security Testing Guide