A Web-Native Answer to MCP
If you’ve been following the agent tooling conversation lately, you’ve probably seen some version of this debate play out..
“MCP is the future.”
“MCP is how agents talk to tools.”
“MCP replaces APIs.”
And almost immediately, the pushback:
“MCP is just an API.”
“Why is this not OpenAPI?”
“Why do I need a server to call an API?”
The phrase that keeps showing up is blunt but telling:
“MCP is spelled API.”
That reaction isn’t a dunk. It’s a signal.
It’s web engineers reacting to a solution that feels misaligned with how the web actually works.
MCP Makes Sense.. for Applications
MCP is a strong solution in the environment it was designed for. Desktop applications, native tools, and local runtimes never had a clean, standardized way to expose capabilities programmatically. Embedding a server into an application so an agent can interact with it is a reasonable and powerful model.
Agents showed up, and suddenly that gap mattered.
MCP fills it.
Web APIs Are a Different Problem
Web APIs already have a contract (OpenAPI), authentication, versioning, and ownership boundaries.
When MCP is projected onto web APIs, something feels off.
That’s where the tension comes from.
Not because MCP is wrong.. but because it’s solving a different problem.
Open Context Protocol
Open Context Protocol (OCP) is what MCP should have looked like for web APIs.
Not a replacement.
Not a competitor.
A different lane.
OCP starts from a simple premise:
The web already won.
OpenAPI already describes what an API can do.
Forcing web APIs to behave like desktop applications is the wrong abstraction.
So OCP flips the model.
Instead of forcing APIs to adapt to agents, OCP makes agents adapt to the web.
The Mic Drops
Automatic Tool Discovery from OpenAPI
Given an OpenAPI spec, OCP defines how to deterministically generate callable tools.
Same spec in. Same tools out.
If an API already has an OpenAPI definition, agents can start using it as a tool immediately.
Web-Native Context
Agents don’t operate in single calls. They operate in workflows.
OCP defines a standard way to carry context across requests using HTTP headers. APIs can participate in that context if they want to.. but they don’t have to. Nothing breaks if they don’t opt in.
That means existing APIs work immediately, without coordination, migration, or new infrastructure.
This Isn’t Just a Spec
OCP is not a whitepaper or a proposal.
It’s an end-to-end ecosystem that exists today.
- Specification defining discovery, context, and OpenAPI extensions
- Public registry where APIs are indexed and searchable as agent tools
- Website to browse and explore available tools
- Client libraries that handle discovery and integration
- VS Code extension that lets you pull real APIs into VS Code or Cursor with minimal setup
- OpenAPI extension schema so APIs can explicitly describe agent-aware behavior without breaking existing clients
- Production infrastructure behind the registry and site
This is designed to be dropped into real workflows, not demo environments.
Clear Positioning
To be explicit:
- MCP is a great solution for applications
- OCP is the right solution for web APIs
This is not an “us vs them” story.
It’s about using the right abstraction for the right environment.
Web APIs don’t need to be reinvented.
They needed a thin, web-native layer that agents could rely on.
That layer exists now.
This Is a Community Project
I don’t think OCP is perfect.
There are rough edges. There are things I missed. That’s unavoidable when building something this broad.
And I don’t want this to be a “look what I built” project.
If OCP is going to matter, it has to be shaped by the people who build and operate APIs every day.
Feedback is welcome.
Issues are welcome.
Contributors are welcome.
This is the first real version of something I wish existed months ago.
If you’ve been frustrated by the web-side MCP conversation, take a look. Kick the tires. Tell me what’s wrong.
Open Context Protocol is live.
You can browse the registry, read the spec, try the VS Code extension, and start using real APIs as agent tools today.