R143 · Agent principles and patterns › Agent interaction protocols

MCP vs API: an adapter in front of the same endpoints

Read the original

mcpagent-protocolsagent-authlearning-resources

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.

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 pictureWhat is actually trueWhy it matters
"MCP Protocol" drawn as a hub chip, mirroring the API gatewayMCP 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, GitHubIn 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 noneRemote 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.

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:

  1. Wrong tool picks from vague or overlapping descriptions; worse as the tool count grows.

  2. A second path to the data that skips the gateway's auth, quotas and audit.

  3. Over-broad tools (a generic execute_sql or run_command) that turn tool choice into arbitrary code execution; split read and write tools so the read path cannot write (R055).

  4. Context bloat from loading every schema on every turn.

  5. Prompt injection through tool results, which reach the model as text it may act on.

  6. Silent drift when the API underneath changes and the tool description does not.

Review checklist

Sources

Connections

See R143 on the knowledge map

Part of the Research notes on nowucca.com. Figures and claims are the source's own unless the summary says otherwise.