The post's main claim holds: an MCP server is an adapter that lets a model call the same APIs your app already calls, not a replacement for them. Its "the agent worked it out" framing oversells discovery, though, and the current MCP spec (2026-07-28) makes MCP look more like an ordinary stateless HTTP API than the post suggests.
What the post says
Luís Rodrigues's post (18 Nov 2026, about 470 reactions; whiteboard credited as inspired by Rahul Agarwal) draws two call paths to the same three back ends: Google Drive, Postgres and GitHub.
API path. A web or mobile app sends a REST/JSON request; an API gateway validates the token and routes it; a service queries the data and returns JSON. Every hop is hand-built and someone operates it.
MCP path. An agent connects through "the MCP protocol" to MCP servers A, B and C, reads how each describes its capabilities, picks one, and gets results back in the same format.
Its thesis, in its own words: an API "expects the caller to know what to request", while MCP "shows the caller what it's able to request". MCP sits in front of the same endpoints; the API still does the work. Several commenters added the point the post skips: the hard engineering is in permissions, tool validation and reliable execution.
Corrections and missing pieces
The diagram is a fair first picture for a newcomer. Five points need fixing before it is used to teach engineers.
| Post's claim or picture | What is actually true | Why it matters |
|---|---|---|
| "MCP Protocol" drawn as a hub chip, mirroring the API gateway | MCP has no central hub. The host app runs one client per server, each a separate JSON-RPC 2.0 connection (stdio locally, Streamable HTTP remotely). A gateway is something you add, as Uber did (R071). | The hub suggests a policy point exists by default. It does not; without a gateway each server is its own trust boundary. |
| The agent "checks which servers are available" | The host is configured with a list of servers. Discovery is per server: tools/list (and resources, prompts) on servers already connected. Nothing finds servers on the open network. | Someone still decides and reviews which servers an agent may reach. That is a config and governance job. |
| "No one built a custom route. The agent worked it out." | Someone wrote the MCP server, its tool names, JSON Schemas and descriptions. The model picks among them from text the host injects into context. | Tool descriptions are now an interface you version and test; bad ones cause wrong tool picks (R099). |
| MCP server lines go straight to Drive, Postgres, GitHub | In practice the server calls the same APIs, often around the gateway that holds auth, rate limits and audit. | If MCP bypasses the gateway, you have a second, less governed path to the same data. Put tools under the same policy as their HTTP routes (R074). |
| The API path has a token check; the MCP path shows none | Remote MCP servers are OAuth 2.1 resource servers with their own discovery and registration rules (R062). The spec also says a human SHOULD be able to deny tool calls. | Auth and consent are where MCP deployments go wrong, as the top comment says. |
Two omissions are worth one line each. MCP exposes more than tools: resources (readable data) and prompts (templates) too. And discovery costs context: every tool's schema and description sits in the window, which is why large deployments page or filter tool lists (R082, R071).
The 2026-07-28 spec narrows the gap
The latest MCP revision moved MCP toward the shape of an ordinary HTTP API. A staff engineer comparing the two should start from this version, not from the 2025 stateful one.
Stateless requests. The
initializehandshake and theMcp-Session-Idheader are gone. Each request carries its protocol version and client capabilities in_meta, andtools/listno longer varies per connection.Routable at the HTTP layer. Streamable HTTP POSTs must carry
Mcp-MethodandMcp-Nameheaders (for exampletools/callandexecute_sql), so load balancers, gateways and observability can route and log by tool without parsing JSON-RPC bodies.Cacheable discovery. List results carry
ttlMsandcacheScope, and servers SHOULD return tools in a deterministic order, which also helps the model's prompt cache.server/discover. Servers must advertise versions, capabilities and identity up front.Fewer server-initiated calls. Sampling, elicitation and roots requests now come back as an
input_requiredresult the client answers on a retry, rather than as requests from server to client.Long-running work moved to a tasks extension with polling (
tasks/get).
The practical result: the post's "two systems that met in advance" versus "enter a room and ask what's on offer" is now mostly a difference in the description layer. Transport, routing, caching and auth look like the API side. What remains distinct is that the caller is a model choosing from natural-language descriptions, which is the real source of both MCP's flexibility and its failure modes.
When to add MCP, and what breaks
Add an MCP server when a model, not code you control, is the caller and needs to choose among operations at run time. Keep calling the API directly when the call sequence is fixed: a workflow step, a batch job or a UI. A CLI is a third option many coding harnesses prefer for local tools, and one engine can serve both surfaces (R082).
Failure modes to plan for:
Wrong tool picks from vague or overlapping descriptions; worse as the tool count grows.
A second path to the data that skips the gateway's auth, quotas and audit.
Over-broad tools (a generic
execute_sqlorrun_command) that turn tool choice into arbitrary code execution; split read and write tools so the read path cannot write (R055).Context bloat from loading every schema on every turn.
Prompt injection through tool results, which reach the model as text it may act on.
Silent drift when the API underneath changes and the tool description does not.
Review checklist
Each tool maps to an existing, owned API operation, under the same authorization policy as its HTTP route.
Read and write tools are separate; destructive tools need confirmation.
Tool names, schemas and descriptions are versioned and covered by a tool-selection eval.
Remote servers follow the spec's OAuth flow; tokens are scoped per server and never passed through.
Gateway or proxy logs record
Mcp-MethodandMcp-Namefor every call.Tool lists are filtered or paged for the task, not loaded whole.
Tool output is treated as untrusted input by the host.
Related
R062 MCP authorization: OAuth 2.1 for remote tool servers: the token check the whiteboard leaves off the MCP side.
R071 Uber's MCP Gateway: the hub the drawing implies, built for real over 10,000 services.
R074 Omnigraph 0.15: hiding write tools is not denying them: MCP tools under the same policy as their HTTP routes.
R099 Evaluating agents at Amazon: governed tool descriptions, because bad ones cause wrong picks.
R082 Craft Anything: one engine served as both CLI commands and MCP tools.
R055 Relate: read and write split into separate MCP tools.
R135 ha-mcp: a concrete server with safety defaults.
R054 Harness engineering across eleven coding agents: MCP adoption next to skills and ACP.