The Model Context Protocol (MCP) has quickly become one of the hottest and arguably most misunderstood topics in tech circles. As discussions about LLM systems and agentic AI access collide with dreams of autonomous consumption and multi-modal integrations, MCP is set to rapidly reshape how we think about API and AI consumption and design.

But what does this mean for the API landscape? Are APIs becoming obsolete? Or is the MCP paradigm setting the stage for the next generation of API-driven architectures?

Below, we’ll dive into what MCP is and how it’s transforming the API world. We’ll consider what API practitioners need to know and how to respond in this new era.

What is the Model Context Protocol?

MCP is an emerging standard designed to help LLMs and AI agents consume services, tools, and resources in a structured and contextually rich way. The idea is to avoid hitting a static API or utilizing manual context settings. Instead, MCP wraps this process into a flexible and declarative metadata model. This model creates a standard for the MCP client application that hosts the LLM-based tools and aligns them with a standard MCP server, which serves as a connecting node to remote services and data sources.

In many ways, this model reflects the surge of context-rich microservices in the mid-2010s. Instead of loading everything into a single monolith and manually setting context and endpoint interactions, MCP allows you to set a standard for the interactions and then create a web of services and data that can be interacted with based on those standards.

In the above diagram, you can see how this works. In essence, the Host MCP Client is one-half of the standard, with the MCP server offering the second half and most of the processing capability in a distributed service collection. The protocol itself is the intermediary between these pieces, facilitating the connection and function.

Does MCP Make APIs Obsolete?

For many readers, this model is going to seem very familiar: it shares many familiar concepts with API gateways, backends for frontends, and other gateway logic solutions.

This familiarity provides us with a short answer to our question. Does MCP make APIs obsolete? No. In fact, it enhances them significantly.

In this paradigm, APIs aren’t getting replaced by MCPs — APIs continue to do the fundamental work behind digital interactions and service connections. However, the actual connection between LLM models, their data sources, and additional services is significantly simplified and streamlined. Whether fetching data, mutating records, or executing procedures, APIs are still the substrate that MCP operates upon.

MCP does not displace the world of APIs. Instead, it acts as an abstraction layer that allows models to reason about how to use APIs without requiring human-level guidance at every step. It’s a multiplexer, not a replacer, and offers to make more seamless interactions without requiring humans to step in so often.

This relationship mirrors how GraphQL abstracts RESTful endpoints or how Hasura’s Supergraph model enables orchestration across many APIs without the user needing to know the implementation details of each one. MCP simply takes this one step further: instead of developers writing orchestrations, the agents and models do, allowing for more flexibility and performance within a standard framework.

How MCP Enables Agentic API Consumption

This move towards agentic access patterns — where LLM-powered agents consume APIs autonomously — has already begun. This is not a case where MCP establishes a new technology that will sprout from the standard. Instead, MCP has observed the interactions and technological implementations in the wild and is attempting to provide a better standard to govern these interactions.

MCP seeks to govern and improve these interactions through a few key attributes.

Standardized API Metadata for Model Use

The MCP standard defines endpoints and schema interactions but, most importantly, provides a methodology for intended use cases, preconditions, and contextual relevance. In other words, this allows developers to standardize the metadata and its meaning abstracted from custom setups and styles, allowing agents to select the right tool for the right task without having to navigate human variation and stylistic choices.

Reduced Hard-Coded Integrations and Higher Portability

Traditionally, mapping and connecting AI agents to APIs and data sources required bespoke prompts, hardcoded parameter mapping, custom data training, and manual curation. MCP, as a protocol, enables dynamic discovery and usage of APIs based on context, reducing the reliance on hard-coded integrations. This, in turn, makes for much more portable solutions, reducing the technical complexity and weight of even the most complex agentic systems.

Better Access Controls and Security

The MCP framework is an enabling system that offers a standardized methodology for more complex interactions and controls to be built and integrated seamlessly. As an example, solutions such as SPIFFE/SPIRE become far easier to integrate with a standard framework for integration, enabling robust workload and agent identities in a way that is standardized and approachable.

Caveats of MCP

MCPs offer some great solutions to common problems, but, as with any sea change, they also bring new threats. MCP servers are vulnerable to some specific attack vectors. Notably, they abstract away a lot of control to an external tool that the principal user does not always maintain.

For instance, a product may buy into an MCP implementation, only for that MCP to be turned malicious in a targeted attack. This kind of threat, known colloquially as a “rug pull,” is a common supply chain threat in third-party libraries and APIs. However, in the realm of MCP, it may be far more damaging due to the critical nature of the data and interactions being managed at scale.

Additionally, there are issues with the interconnected nature of MCPs. Because MCPs work together collaboratively, there are major threats with tool shadowing (where one server alters or affects the behavior of another), tool poisoning (especially when it comes to data injection), and unsanitized entries or routing for remote command execution.

It’s important to remember that MCP is a nascent standard. It will take some time to fully realize and proactively manage these threats. While they’re certainly not a reason to entirely abandon MCP, they are certainly a reason to adopt a suspicious eye.

A New Paradigm, Not a Replacement

Ultimately, MCP is not a nail in the coffin of APIs or microservices. Instead, it’s the next phase of evolution for the API paradigm in the AI age. We can look to the past to find a similar paradigm shift. Much like how REST rose to prominence in the age of SOAP, not as a replacement but as a paradigm that offered a standard approach for interaction, MCP provides a new paradigm for interaction and integration.

Put simply, API practitioners should view the rise of MCP not as a threat but as an opportunity to future-proof their APIs for the agentic AI era. This also comes with the obvious caveat that not all services need MCP — non-agentic or LLM-tied APIs will not benefit from MCP in the same way. In many ways, this is an AI-specific solution for an AI-specific problem.

APIs remain the critical backbones of modular, flexible solutions for industries as varied as fintech and gaming, and this is not going to disappear anytime soon. MCP ensures that these APIs stay consumable in this new AI landscape.