MCP vs. API: An Untested Opinion

Someone in a Slack channel asked, again, whether anyone's actually testing if coding agents work better against a documented REST API or an MCP server. I've been circling this question for a couple of weeks - reading benchmarks, mostly - and keep arriving at the same annoyed conclusion: most of the "evidence" out there has a seller attached to one side of the answer.

Quick primer: MCP (Model Context Protocol) is a spec for how an agent finds out what a service can do and calls it - a host asks a server "what have you got," gets back a menu of tools, hands that menu to the model. A web API is the standard it's being compared to - REST, GraphQL, whatever - documented endpoints and a schema, called directly, the same way a human developer would.

One report I nearly cited got retracted mid-research. Its "raw API" arm turned out to be a single undocumented endpoint, not a real API. Typed beat untyped - shocking. That's not a test of MCP vs. API. That's a test of whether you wrote any documentation at all.

Get rid of the vendor noise and here's roughly where I land, for now:

• For a coding agent writing integration code, a good OpenAPI spec wins. Agents are good at the same things a competent developer is good at - docs, running curl, writing a ten-line script. Even Anthropic's own fix for MCP's token bloat is "stop calling tools directly, write code against them instead" - a strange thing for the protocol's own inventor to recommend.
• For the ecosystem case - many agent hosts, one service, nobody wants to write glue code per host - MCP's actual value looks like a standardized "protocol" (discovery-and-auth handshake). It seems like real value, but... it's not a performance claim.
• REST had an answer for what MCP pitches back in 2000 (HATEOAS - hypermedia links telling a client what it can do next). (almost) Nobody built it, because it was a pain for human developers. Whether it's a pain for a model too is a question I don't think people have actually answered.

That's my current state. Notice that something's missing: a benchmark. Everything above is other people's numbers, filtered for trust - which is a fine way to form a hypothesis and a bad way to actually build (or win an argument).

So I'm going to build the actual comparison. A small API, documented properly, and an MCP server wrapping the same operations - then run the same tasks through the same agents against both and see what happens, not what I expect to happen. If the take above holds up, I'll say so. If it doesn't, I'll say that louder - the interesting bit here isn't "MCP wins" or "APIs win," it's finding out whether my own reasoning has similar gaps, and learning why (if it does).

Full writeup/case study once it's built. Right now I'm just putting down what I believed going in.