Over the last year, I've noticed an interesting pattern.
A few years ago, every software company wanted a REST API.
Today, many of those same companies are asking a different question:
"How do we make our product work with AI agents?"
That shift made me wonder:
Will having an MCP server eventually become as common as having an API?
I'm not convinced we're there yet.
But I do think we're heading in that direction.
Let's discuss why.
Think back to the early days of APIs.
Many businesses didn't expose one publicly.
Integrations were built manually.
Partners requested CSV exports.
Developers wrote custom scripts.
Everything worked—but only until the next integration request arrived.
Eventually, APIs became the standard because they reduced friction for everyone involved.
Now AI is creating a similar moment.
When people use tools like ChatGPT, Claude, Cursor, or other AI assistants, they don't want to switch between five browser tabs just to complete a task.
Instead, they expect to say something like:
"Create a customer in our CRM."
or
"Generate this invoice."
or
"Show today's failed deployments."
For that to work, the AI needs a reliable way to interact with your product. That's where the conversation around MCP starts.
This is probably the most common question.
Technically, AI can call a REST API.
But here's the problem.
REST APIs were designed for software developers.
Developers read documentation.
Developers understand authentication.
Developers know which endpoint to call first.
Developers combine multiple requests together.
AI agents don't "read documentation" the same way humans do.
They need structured descriptions of available actions.
They need context.
They need discoverable tools.
That's exactly what MCP provides.
This is probably the biggest misconception I see online.
Some people talk about MCP as if REST APIs are becoming obsolete.
I don't think that's true.
Your API is still the foundation.
The MCP server simply becomes another interface for accessing it.
A simple way to think about it is:
One doesn't replace the other.
They solve different problems.
Historically, if you wanted your product to work with different platforms, you often built separate integrations.
One for Slack.
One for Zapier.
One for Teams.
One for internal automation.
Now imagine doing the same thing for every AI platform that appears over the next few years.
That doesn't seem sustainable.
Standards become valuable when ecosystems grow.
That's why MCP has attracted so much attention.
While working on 0mcp (https://0mcp.io), one thing became very clear. Most teams already have everything they need.
They have:
The missing piece isn't the API.
It's making that API understandable to AI systems.
That's why 0mcp focuses on turning existing OpenAPI specifications into hosted MCP servers instead of asking teams to rebuild everything from scratch. If you're curious how the workflow looks, the documentation at ** https://docs.0mcp.io** walks through the process from importing an API to exposing AI-ready tools.
Probably not.
At least, not today.
If your software has no need to interact with AI agents, adding an MCP server just because it's trendy doesn't make much sense. Technology should solve a real problem.
But if your customers are already asking questions like:
...then it's worth paying attention.
I don't think every product will suddenly launch an MCP server next month.
But I do think we'll see a gradual shift.
Five years ago, companies proudly announced they had an API.
Today, nobody makes that announcement because it's expected.
I wouldn't be surprised if MCP follows a similar path.
Not because it's fashionable.
But because AI tools need a consistent way to interact with software.
I wouldn't recommend throwing away your existing APIs.
Invest in them.
Keep your OpenAPI specification up to date.
Design clear endpoints.
Good APIs become even more valuable in the AI era.
When you're ready to expose those capabilities to AI clients, standards like MCP can build on top of the work you've already done rather than replacing it.
That's one of the reasons we built 0mcp—to help teams reuse the APIs they already have instead of starting from zero. You can learn more on the homepage (https://0mcp.io) or explore the guides and examples in the documentation (https://docs.0mcp.io).
This is still an evolving space.
Some teams are already exposing MCP servers.
Others are experimenting.
Many are still deciding whether they need one at all.
So I'm curious:
Do you think MCP servers will become as common as REST APIs, or will they remain a niche tool for AI-focused products?
Let's discuss in the comments.