MCP Explained: Why Exposing Capabilities Beats Fixed Endpoints for Agents
What MCP is and why it matters: Model Context Protocol clients and servers, how it differs from a fixed API, and what Figma and Render show about AI agents.
This article is published in English.
Sooner or later every developer runs into the three letters MCP. Try Supabase, or Figma, or almost any developer product, and it turns out to offer an MCP of its own. The usual reaction is to nod along without really knowing what the term covers or how it is supposed to help. This is a plain-language explanation.
A small example shows the effect. A landing page had to be built for an app, with a Figma design as the starting point. The AI assistant suggested connecting Figma's MCP server. Once connected, the page came together in minutes without anyone hand-writing the layout code. The interesting questions are what MCP is and why it changes things.
How backends have always worked
When a conventional API is designed, its purpose is already known. A client wants a list of products, and the service fetches exactly that, perhaps through SELECT * FROM products or a repository call such as productRepository.find() when an ORM is involved. The endpoint is shaped around one fixed purpose, and nothing about it is open-ended.
That is the bargain of traditional APIs. The client knows what it wants, and the developer builds narrowly for that want. The intent is settled before a single line of the endpoint is written.
What AI changed
People are no longer the only ones touching an application. AI agents need to use it as well, which prompts an obvious thought: why not simply let them call the existing APIs, as any human-facing client does?
The trouble is that an API presumes a known use case. With agents, the developer often cannot say in advance what they will want to do. So instead of one more rigid, narrow endpoint, MCP aims to open wider parts of an application so an AI can explore them and use them as needed.
A definition
MCP, the Model Context Protocol, is an open standard introduced by Anthropic. It describes a common way for AI applications, Claude for instance, to connect to outside tools, data sources and systems. It is a protocol, a convention that every agent follows, and not a particular product or integration. Anyone can build to it.
In practice it splits into a client and a server. An application, or a service like Figma or Render, exposes an MCP server. An AI application such as Claude acts as the MCP client and connects to it. The server declares what is available, and the client discovers and uses it.
The server side rests on a few core pieces:
- Tools that the agent can invoke.
- Resources that it can read.
- Prompts that can be reused, so it does not have to guess how to approach a common task.
The client side has one piece of its own, called roots, which marks the boundaries of what a server may access. Any agent that understands MCP already understands all of these, which is why connecting becomes plug-and-play instead of custom integration work each time.
A security benefit
MCP also helps with safety. The agent still reaches your data, though only indirectly. The server is the only component that talks to the database, and it offers just the capabilities that were defined. The agent cannot run queries of its own or see the schema. It interacts with the interface that was built, while the server does the real work on its behalf. The abstraction can be pushed as far as desired, so the agent knows little about internal implementation.
All of this sits on top of existing APIs and does not replace them. MCP wraps them in a standard, discoverable interface any AI agent can connect to and understand. The major shift from an ordinary API is that nobody decides up front exactly what a client may do. A wider range of what is available, whether tools, resources or data, is exposed, and the agent works out from the situation at hand how to put them to use.
Once an agent connects, it discovers the exposed capabilities and reasons over them to complete a task, so nobody has to hard-code every action it might ever want.
A worked example with Figma and Claude
The landing page story is the clearest way to see what changes. For UI and styling work, the usual routine is screenshot-driven: capture the design, give it to an agent, then go back and forth, pointing out what was missed, zooming into a detail, explaining intent. A human eye catches things that an agent looking at a flat image cannot judge as precisely.
This time the first step was different. The agent was told the goal and asked for the best way to achieve it, and it proposed Figma's MCP. That is a good habit in general. An AI is a prediction engine, and the quality of its answer depends heavily on the context it receives. It often pays to ask the AI itself for the best approach instead of limiting it to methods already known. Boxing it in wastes its strengths, particularly when the task is unfamiliar. Here the recommendation was an MCP.
Next the Figma MCP was set up locally, and Claude was connected to it. After authentication the design data became available, so Claude could read the real design directly and no screenshots were needed. It went through the design in stages, broke the work into a plan and carried it out. The output was close to finished, nearly a one-shot implementation and almost perfect.
In effect MCP gave the agent the same eyes a person has. Nobody had to act as middleman, translating what is visible in the design into something the agent can use, because the agent could look at the design itself.
Why providers should care
The Figma case was about consuming somebody else's server. It also raises the question of building one for an application, so agents, and the people behind them, can do more than was originally planned.
Render, a platform for deploying applications, offers an example. Its MCP server exposes deployment logs, service metrics such as CPU, memory and request latency, and even read-only access to a Postgres database. Normally all of that requires logging into the Render dashboard. With the MCP server connected, someone can ask an agent to build a custom dashboard of deployment statistics, flag a burst of error logs or track resource usage over time. Render never had to anticipate that dashboard or ship an API for it. It exposes underlying capabilities, and the agent assembles them into whatever is needed.
Here is the core point. A developer might assume customers want feature ABC when they actually want XYZ. If only fixed APIs exist, users are limited to what the developer thought to offer. MCP reverses that. It does not confine the agent, or the user behind it, to what was predefined. It lays out what the application can do and leaves the decision about what to build to the agent, the way Render's server leaves the dashboard decision to the user.
So rather than a user dashboard with a handful of designed views, a user can ask an agent for a fully custom view, and the agent can build it, because it sees what is possible inside the application. The message to users changes from a list of fixed things they can do with the app to a description of what the app can do, with them working out what they need.
Because MCP is a standard, this reaches well beyond one app and one agent. Any agent that speaks MCP can connect to any application that exposes it, using the same protocol. That is why it counts as a real shift and not a convenience feature.
The mindset change
MCP is not merely APIs for AI. It is a change of attitude, away from building for a specific, known use case and toward exposing possibilities and letting an AI, guided by context, decide what to do with them. It is also a safer way to let agents interact with an application, since they never get direct access to the database or internals. They see only the interface that was chosen, and the MCP server does the actual work behind it.
Anyone building something that AI agents might touch should understand this boundary: what is predefined versus what is made possible.