# A Healthy MCP Gateway Is Not a Working One: What to Test Before Centralizing Agent Tool Access

> A shared gateway for AI agents' internal tools can pass every health check and still break sign-in or hide an action that already ran. One October 2026 MCP gateway rollout, read against the current MCP authorization rules, shows what to test before calling it working.

**Published:** November 19, 2026
**Author:** PSEEDR
**Category:** stack
**Content tier:** free
**Accessible for free:** true
**Editorial format:** analysis
**News quality eligible:** true
**Source count:** 16
**Word count:** 3166

**Read time:** 14 min  


**Canonical URL:** https://pseedr.com/stack/a-healthy-mcp-gateway-is-not-a-working-one-what-to-test-before-centralizing-agen

![A dark network gateway appliance with a steady blue light, its glowing cable bending toward a closed side door instead of the open route, under the headline Healthy Isn't Working.](https://storage.googleapis.com/pseedr-content/assets/article-covers/a-healthy-mcp-gateway-is-not-a-working-one-what-to-test-before-centralizing-agen.8c88c459.png)

---

*A shared gateway in front of AI agents’ internal tools adds more than a single point of failure. It becomes the address that sign-in and metadata checks must match, and the place where a lost response can hide an action that already ran. One October 2026 rollout shows what to verify before calling it done.*

<div class="section" aria-label="Companion video" style="margin:1.5rem 0 2rem">

## Watch the full analysis (14:24)

<div style="position:relative;width:100%;aspect-ratio:16/9">

</div>

[Watch the full analysis (14:24) on YouTube](https://www.youtube.com/watch?v=cMPiS7cvBrs) · [Watch the Short (0:54)](https://www.youtube.com/shorts/hQcmXaJhaww)

Join the discussion: [LinkedIn](https://www.linkedin.com/feed/update/urn:li:share:7529233800447377408/) · [X](https://x.com/PSEEDR/status/2123467544443121689)

</div>

On October 1, 2026, Uber’s engineering team published [a description of its MCP Gateway](https://www.uber.com/blog/designing-mcp-gateway/), the service that sits between the company’s AI agents and its existing back-end systems. Uber reports that the gateway hosts more than 800 MCP servers and more than 5,000 tools, and it explains why the company built one: “Individual teams independently built integrations, leading to fragmentation in tooling and duplicated infrastructure.” On November 4, an [explainer video](https://www.youtube.com/watch?v=DZ5fCu2eH2Q) sponsored by Arcade, which offers an MCP runtime, walked a wider audience through the design.

For platform, API and SRE engineers who connect agents to internal APIs, that raises two decisions. Should tool access run through a shared gateway or registry, or should each team keep running its own tool servers? And if the gateway gets built, what evidence shows that it works?

The standard worry is availability. The explainer states it directly: “Every request on this path now relies on the gateway.” A [2025 security analysis of MCP](https://arxiv.org/html/2511.20920v1) by Herman Errico, Jiquan Ngiam and Shanita Sojan adds latency to the list and warns that “the gateway can become a single point of failure if it is not designed for high availability.” The authors recommend redundant instances, health checks and an explicit choice between failing open and failing closed, and they present these as design recommendations, not measured results. The concern is valid, but it treats the gateway as a pipe that is either up or down.

In one recent rollout, the failures that surfaced were not about whether the gateway was running. Scott Stouffer, co-founder and CTO of [Market Brew](https://marketbrew.ai), described in a written response to PSEEDR how the company deployed a shared MCP gateway for its internal engineering tools in October 2026; he disclosed that his team uses Codex and MCP in its engineering workflow. His summary of the lesson: “centralizing tool access also centralizes integration assumptions.” This article follows two of those assumptions: the identity and address that clients see, and what happens when the gateway cannot tell whether an action ran. Neither shows up in a process health check.

## What actually moves behind the gateway

Uber’s post separates two jobs. The MCP Registry is the control plane: a catalog that records which servers and tools exist, who owns them and whether they are enabled. The Proxy Gateway is the data plane: it receives MCP calls at runtime, translates them into HTTP, gRPC or TChannel requests, forwards them and converts the responses back. An automated crawler reads Uber’s API definitions and registers the derived tools in a disabled state. The post calls this a core design principle: “discovery doesn’t imply exposure.” Owning teams review and enable each tool, every change to a tool description produces a configuration diff that server owners must approve, and owners can roll back to an earlier version. The gateway also applies authorization and redaction of sensitive data at tool-level granularity.

Most of those benefits are decided in the control plane: review before a tool becomes callable, one place to see what exists, consistent policy. The data plane then has to carry each decision into every request. According to Uber, the data plane “refreshes its in-memory state at a fixed cadence,” so configuration changes take effect without restarts. The explainer turns that into a test question. If refunds are disabled, “the update needs to reach them, too. Otherwise, an instance with old instructions could behave differently.” The presenter is explicit that this is “a question to test in our design, not a reported Uber incident.” Uber’s post does not discuss outages, fallback or retries, so nothing here describes how Uber’s gateway behaves when something fails.

Stouffer gave his gateway a deliberately narrow role. “We wanted a consistent entry point and authorization flow while retaining the permissions enforced by each local tool service,” he wrote. The gateway used restricted relays to the development environments. “Routing through one gateway was not a reason to give it unrestricted command execution.” Keeping enforcement in each tool service means a gateway mistake is less likely to be the only barrier in front of a sensitive action. It also means the gateway adds a layer instead of replacing one, and that layer brings its own assumptions. The explainer’s fictional refund demo makes a related point: a tool hidden from a caller’s list must still be refused, because “Hiding a button isn’t enough here. The server must reject the request, too.”

## Failure point one: the gateway becomes the identity clients check

The first problem Stouffer described appeared at sign-in: “a browser login was redirected toward an internal origin.” His team restored the narrower route that had been working, corrected the redirect and cookie-domain handling, and then verified login through the trusted public HTTPS route. A second check, during app creation, “exposed discovery metadata that redirected instead of returning the expected issuer and resource information.” The team corrected that binding and checked the actual response before going further.

Failures like these do not require anything to crash. Placing a gateway in front of tool servers changes the addresses and names that clients compare during authorization, and those comparisons are strict.

The current MCP specification is [revision 2026-07-28](https://modelcontextprotocol.io/specification/versioning). Its [authorization section](https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization) requires MCP servers to publish OAuth 2.0 Protected Resource Metadata as defined in [RFC 9728](https://datatracker.ietf.org/doc/html/rfc9728), and requires clients to use that document to discover the authorization server. The metadata names the protected resource. Under RFC 9728 Section 3.3, the `resource` value returned must be identical to the resource identifier the client used to build the metadata URL or, when the client found the metadata through a `WWW-Authenticate` header, identical to the URL the client requested. “If these values are not identical, the data contained in the response MUST NOT be used.”

The 2026-07-28 revision adds a second exact comparison. Before sending the browser to sign in, the client must record the `issuer` from the authorization server’s validated metadata. When the browser returns, the client must compare any `iss` value in the authorization response with that record by simple string comparison, and clients “MUST NOT apply scheme or host case folding, default-port elision, trailing-slash, or percent-encoding normalization” before comparing. The specification’s [security considerations](https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization/security-considerations) also require that all redirect URIs be either `localhost` or HTTPS, and that authorization servers “validate exact redirect URIs against pre-registered values.”

PSEEDR’s reading of these rules is that once a gateway becomes the public entry point, its public URL is the resource identifier clients compare against, and if the gateway also fronts the sign-in flow, the issuer and redirect addresses that clients see change with it. An internal hostname, port or path that leaks into the metadata body, the issuer or a redirect gives a specification-following client a legitimate reason to stop, while every process reports healthy. A metadata endpoint that answers with a redirect is a related hazard. RFC 9728 says nothing about redirects when fetching metadata, but MCP’s [2025-11-25 security best practices](https://modelcontextprotocol.io/specification/2025-11-25/basic/security_best_practices) advise clients, in guidance on server-side request forgery, to “not blindly follow redirects to internal resources” and to “consider disabling automatic redirect following and validating each hop.” A client following that advice may fail at the redirect. A client that follows the redirect may reach metadata whose `resource` no longer matches. Cookies add a browser-level version of the same problem: a browser sends a cookie only to the domain it was scoped to, so a sign-in journey that crosses between an internal origin and the public one can lose its session along the way.

Stouffer did not say which client his team used or which check failed. The mapping above explains why such failures break a flow; it does not reconstruct his root causes.

Token handling belongs to the same set of assumptions. The 2026-07-28 rules require an MCP server to accept only tokens issued for it. When it calls an upstream API, it uses a separate token issued by the upstream authorization server: “The MCP server MUST NOT pass through the token it received from the MCP client.” A gateway design has to state which component is the audience for the client’s token and which credential each downstream call carries.

## Failure point two: the response is lost, but the action may have run

The second assumption concerns outcomes. “One rule we retained is that a request with a potentially consequential outcome is not automatically replayed after forwarding begins,” Stouffer wrote. His reason: “A gateway can lose the response after the backend has acted. In that case, we inspect the receipt or resulting state before deciding what to do next.”

The underlying problem is old, and a gateway places itself in the middle of it on every forwarded tool call. The IETF’s [draft on the Idempotency-Key header](https://www.ietf.org/archive/id/draft-ietf-httpapi-idempotency-key-header-07.html) describes a client whose `POST` request timed out: “The client is left uncertain about the status of the resource.” The draft goes on to say that the client “does not know if it can safely retry the request.”

Common proxy settings do not draw this line on their own. [Envoy’s router documentation](https://www.envoyproxy.io/docs/envoy/latest/configuration/http/http_filters/router_filter) says Envoy does not retry unless configured to. Once configured, its `5xx`, `gateway-error` and `reset` policies retry when the upstream “does not respond at all (disconnect/reset/read timeout)”, and a read timeout can occur after the upstream has received the request. The `reset-before-request` policy, by contrast, retries only requests that “have not been sent to the upstream server.” Envoy is one example. Other proxies have their own semantics, and nothing in the material discussed here says what any of these deployments run.

The tool definition cannot settle the question either. In MCP’s [2025-11-25 schema](https://modelcontextprotocol.io/specification/2025-11-25/schema), the `idempotentHint` annotation defaults to false and `destructiveHint` defaults to true, and the schema warns that annotations are only hints: “Clients should never make tool use decisions based on ToolAnnotations received from untrusted servers.” Cancelling does not settle it. The same schema says of a cancellation notice that “it is always possible that this notification MAY arrive after the request has already finished.”

One further consequence is easy to miss. Stopping the gateway from replaying a call does not stop the agent from repeating it. MCP’s [tools specification](https://modelcontextprotocol.io/specification/2025-11-25/server/tools) describes tool execution errors as feedback “that language models can use to self-correct and retry with adjusted parameters.” In PSEEDR’s view, a gateway that reports an ambiguous outcome as an ordinary failure invites the model to call the tool again. Reporting that the outcome is unknown, separately from a definite failure, gives the agent and its operator a reason to check first. Stouffer did not describe what his gateway returns in this case.

Teams have three broad options, and they suit different conditions:

| Approach | What it handles | What it requires or leaves open |
|----|----|----|
| Do not replay after forwarding begins; check the receipt or resulting state (Stouffer’s rule) | Prevents the gateway from duplicating a consequential action | The backend must expose a receipt or queryable state, and the checks must keep pace with volume |
| Idempotency keys enforced by the backend | A retry with the same key returns the earlier result instead of acting twice | Backend support; the key must exist before forwarding and survive the trip through the gateway; the header is still a proposal |
| Retry only requests not yet sent (for example, Envoy’s `reset-before-request`) | Recovers from failures before the backend saw anything | Does not resolve the ambiguous case; it only declines to retry it |

The idempotency draft describes what a key buys: the resource returns the result of an already completed operation, answers a concurrent duplicate with a 409 conflict, and refuses reuse of a key with a different payload. The version consulted, draft-07 from October 2025, lists an expiry date of April 18, 2026. PSEEDR did not confirm its current status, so it is described here as a proposed mechanism, not a standard. Stouffer did not say what his team’s receipt or state inspection looks like or how often it is needed.

## What counts as acceptance evidence

Stouffer listed the evidence his team accepted: successful tool discovery and controlled reads, denied paths outside the gateway’s scope, and readiness checks after a controlled restart of a networking service. He stated the limit himself: “Those are specific deployment checks, not proof that every tool or failure mode was covered.” His broader advice was to check the full authentication journey, the resource binding and the failure behavior, “rather than accepting a healthy gateway process as evidence that the workflow works.”

The table below separates the checks Stouffer reported from additional checks PSEEDR suggests on the basis of the specifications and the Uber material. Each row says what a pass supports and what it leaves open.

| Check | Reported or suggested by | What a pass supports | What it leaves open |
|----|----|----|----|
| Gateway process healthy, readiness passes | Baseline | Instances run and accept connections | Sign-in, metadata binding and permissions |
| Readiness after a controlled networking-service restart | Stouffer | The tested restart path recovers | High availability of the public entry point |
| Full browser sign-in through the public HTTPS route | Stouffer | Redirects and cookies work for the public address | Other clients and other tools |
| Fetch the protected-resource and authorization-server metadata and read the bodies: a direct 200, `resource` equal to the public identifier, the expected issuer | Stouffer checked the actual response; the field-level detail is PSEEDR’s, from RFC 9728 and MCP 2026-07-28 | Clients can trust the advertised identity | Whether each server validates token audience at runtime |
| Tool discovery and controlled reads | Stouffer | The discovery and read paths work | What writes do when something fails |
| Calls outside the gateway’s scope are refused | Stouffer | Scope is enforced on the server for the paths tried | Every combination of caller and tool |
| Upstream calls do not reuse the token the client presented | PSEEDR, from MCP 2026-07-28 | No token passthrough on the tested routes | Routes not exercised |
| Drop the response to a consequential call after forwarding | PSEEDR, built on Stouffer’s rule | No automatic replay; the outcome is reported as unknown; a receipt can be found | Whether the backend itself is idempotent |
| Disable a tool and time when every instance stops serving it | PSEEDR, from the explainer’s design question and Uber’s fixed-cadence refresh | The actual propagation window | Behavior under partial failure of the configuration source |

The explainer’s closing advice is a compact version of the same discipline: “Follow one request from the beginning to end. Ask who can make it, where it can be stopped, and what happens if a step fails.”

## When a gateway is not worth it yet

Gateways are also being sold as products. Scalekit [promoted](https://www.youtube.com/watch?v=NA2vZlacphk) AgentKit, its MCP gateway, on November 2, and Amazon’s [Bedrock AgentCore documentation](https://docs.aws.amazon.com/bedrock-agentcore/) describes a managed gateway for making APIs, Lambda functions and MCP servers available to agents. That does not mean every team needs one. Two sources with commercial interests of their own disagree about when a gateway is worth it, and the disagreement is useful.

[Obot](https://obot.ai/blog/single-mcp-gateway-vs-multiple-mcp-servers/), which offers an open-source MCP gateway and a managed version of it, still advises against adding one early. Its post lists the costs of doing so (“Extra deployment surface,” “Extra failure points,” “More operational overhead”) and says that “For a single developer, a gateway often solves problems you don’t have yet.” In its view, “The architectural inflection point here is not routing, it’s OAuth”: multiple developers, shared tool access, identity-provider integration, audit requirements and fine-grained access control.

Lidan Hazout, CTO of Capsule Security, which sells runtime protection for AI agents, goes further in a [March 2026 Security Boulevard piece](https://securityboulevard.com/2026/03/why-mcp-gateways-are-a-bad-idea-and-what-to-do-instead/). He argues that “Gateways only see what goes through MCP,” not the shell commands, SDK calls and direct connections agents also use; that routing credentials through a gateway means “you have just increased the number of places where your secrets exist”; and that “Without full session context, advanced detection is almost impossible.” He proposes hooks inside the agent runtime, combined with an MCP registry that keeps an allowlist of approved servers.

The split between control plane and data plane helps sort these views. Review before activation and an allowlist are control-plane functions. Uber pairs them with a proxy on every call; Hazout pairs a registry with checks inside the agent. A team that mainly needs to know which tools exist and who approved them can get that without putting a proxy on the request path. A team whose real need is shared identity, audit and consistent authorization across many tool servers has the case Obot describes for a central entry point, and takes on the identity and outcome checks above.

A team that does route traffic through a gateway also has to plan for the entry point itself. “Our backend routing options do not, by themselves, make the public entry point highly available,” Stouffer wrote. The explainer names the operational minimum as multiple instances, monitoring and a team responsible for keeping the gateway running, and the arXiv authors add the decision about whether a degraded gateway should fail open or closed. None of these sources measured how often gateways fail, so this is a planning requirement, not a failure rate.

## The answer, and what remains open

The available evidence does not measure whether centralizing paid off. Uber reports scale and design, not outage or cost data. Stouffer reports which checks passed, not a before-and-after comparison, and his account covers one company’s rollout of internal engineering tools.

What the evidence supports is a conditional answer. A shared gateway earns its place when shared identity, audit and review before activation are real needs, and its cost appears as new integration assumptions, not only as a new point of failure. Call it working when sign-in succeeds end to end through the public URL, when the metadata bodies name the public resource and issuer, when the server refuses out-of-scope calls, when a disabled tool stops working on every instance within a known window, and when a consequential call whose response is lost is neither replayed nor reported as an ordinary failure. A healthy process is where that testing starts.

One question remains open. Checking a receipt by hand works while consequential tool calls are few. At what volume does that inspection stop keeping up, so that idempotency enforced by the backend becomes the only workable answer? Teams running gateways at different scales are best placed to say where that line falls.

*Reporting note: Stouffer’s account was supplied in a written response to PSEEDR and was not independently reproduced. He co-founded the company whose rollout he described. Uber’s figures are Uber’s own; the explainer video was sponsored, and its stale-instance scenario is hypothetical. Obot and Capsule Security sell products related to the approaches they favor, and the arXiv paper’s gateway points are recommendations without benchmarks. The mapping of Stouffer’s failures to specification rules, and the checks beyond those he reported, are PSEEDR’s analysis.*

## Sources

- https://www.uber.com/blog/designing-mcp-gateway/
- https://www.youtube.com/watch?v=DZ5fCu2eH2Q
- https://arxiv.org/html/2511.20920v1
- https://modelcontextprotocol.io/specification/versioning
- https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization
- https://datatracker.ietf.org/doc/html/rfc9728
- https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization/security-considerations
- https://modelcontextprotocol.io/specification/2025-11-25/basic/security_best_practices
- https://www.ietf.org/archive/id/draft-ietf-httpapi-idempotency-key-header-07.html
- https://www.envoyproxy.io/docs/envoy/latest/configuration/http/http_filters/router_filter
- https://modelcontextprotocol.io/specification/2025-11-25/schema
- https://modelcontextprotocol.io/specification/2025-11-25/server/tools
- https://www.youtube.com/watch?v=NA2vZlacphk
- https://docs.aws.amazon.com/bedrock-agentcore/
- https://obot.ai/blog/single-mcp-gateway-vs-multiple-mcp-servers/
- https://securityboulevard.com/2026/03/why-mcp-gateways-are-a-bad-idea-and-what-to-do-instead/
