Your Next User Is an Agent: Why Every Product Needs an MCP Server

For forty years we built software for people. Now AI agents are using it too, and most products have no front door for them. An MCP server is that door, and designing it well is a product decision before it is a technical one.

7 min read
A person using an app on a laptop while a robot plugs into a dedicated port on the same app

For forty years we built software for people. Now AI agents are using it too, and most products have no front door for them. An MCP server is that door, and designing it well is a product decision before it is a technical one.

Software has always had one kind of user

Every screen we design assumes a person on the other side. Someone who reads a label, guesses what a button does, notices when something looks wrong and stops.

APIs widened that a little. They let other programs in, but those programs were written by developers who read the documentation, handled the edge cases and tested everything before going live. Behind every API call there was still a person who had thought it through in advance.

That assumption is breaking. More and more of the requests that reach our products come from AI agents acting on someone's behalf: booking, buying, filing, updating, summarising. They decide at runtime which function to call and with which parameters. Nobody wrote that exact sequence beforehand.

In other words, software has a new kind of user. And most of it was never designed for that user.

Agents are already knocking

Last week United Airlines decided that unauthorised personal AI agents can no longer book flights on its website and app. eBay had already banned unapproved "buy for me" agents. The reasons given are serious: shared credentials, unintended purchases, rules that require a human confirmation.

I read these decisions as a symptom. Agents arrive anyway. When a product offers them no proper entrance, they come in through the window: they drive the user interface like a person would, with the user's password, and nobody can tell afterwards who did what. Blocking them is the only defence left when no proper door exists.

The alternative is to build that door on purpose.

Why MCP, and why now

The Model Context Protocol is an open standard for exactly this. An MCP server describes what a product can do as a set of tools, each with a name, a description and typed inputs, in a form any compatible agent can discover and use.

Anthropic introduced it at the end of 2024. Since then OpenAI, Google and Microsoft have adopted it, and in December 2025 it was donated to the Agentic AI Foundation under the Linux Foundation, so no single vendor controls it. For a technology decision, that matters: building on MCP today does not tie a product to one AI provider.

A fair question is why a REST API is not enough. An API tells a developer what is possible. An MCP server tells an agent what is possible, when it makes sense, and what happens if it gets it wrong. The difference sounds small. In practice it changes how you design almost everything.

What I learned building one

My personal assistant, a side project, exposes an MCP server. Through it an agent logs my meals, reads my calendar, manages my shopping list and prepares my social media posts. The posts I published this week were drafted, illustrated and scheduled that way.

Three lessons from building it surprised me.

The description is the interface. An agent has no screen. What it knows about a tool is what the description says. The tool that schedules a post states plainly that scheduling is a real publication on my profile, and that it should only happen for content I have seen and asked to publish. That sentence does the job a confirmation dialog does for a person.

Agents take you literally, and fill the gaps creatively. My first drafting tool rewrote the text it received and filled any placeholder with invented content. Helpful for a person brainstorming, dangerous for an agent passing on a finished text. I added an explicit option to save the text exactly as given. Every tool should say what it will do with its input, including what it will change.

Boundaries belong in the server, not in the prompt. Some things the agent simply cannot do through my server: it cannot edit a post once it is in the publishing queue. I do not rely on the model remembering a rule. If an action should not happen, the tool for it does not exist.

Designing for an agent is different from designing for a developer

From those lessons, and from watching agents use other products, I would design every MCP server around a few principles.

  1. Tools named after intentions, not endpoints. "Schedule a post" beats "PATCH /drafts/{id}/status". The agent is matching a user's request to a capability, so speak in the user's language.
  2. Read and write kept apart. Reading data and changing it are different risk classes. Start with read-only tools, and add write tools one at a time, when you can see how they are used.
  3. A human step for irreversible actions. Payments, deletions, anything with legal weight: the server returns a request for confirmation, and the user approves it outside the agent.
  4. Errors that explain. "400 Bad Request" teaches an agent nothing. "The date must be in the future; you sent yesterday" lets it fix the call on its own.
  5. An identity for the agent. The agent should act with its own credentials and scopes, on behalf of a user, never with the user's password. Then permissions can be narrower than the user's, and revocable.
  6. A log of who did what. Every call recorded with agent, user and delegation. When something goes wrong, that is the first question anyone will ask.

None of this is exotic. It is good API design, plus the guardrails we already put around people: confirmations, permissions, audit trails. The difference is that with agents they cannot live only in the user interface, because there is no user interface.

A product decision first

It is tempting to treat an MCP server as an integration task for the platform team. I think that undersells it.

Deciding which capabilities to expose, which ones need a human, how much an agent may request and how you will know what it did: these are decisions about the product, the risk and the relationship with the customer. They involve product managers, security, legal and support as much as engineers.

And they have a commercial side. As more customers delegate tasks to their agents, a product that agents can use well will be chosen more often. A product that offers only a login form will be used through the window, or skipped.

What to do right now

  • Find out who is already knocking. Look at your traffic for automated sessions that behave like agents. They are likely there already.
  • Pick three read-only capabilities your customers ask about most, and expose them through an MCP server. Measure how they are used.
  • Write the tool descriptions as carefully as your best user interface copy. For an agent, they are the user interface.
  • Decide your rules before the first write tool: identity, scopes, confirmations, limits, logging. Put them in the server, not in a document nobody reads.
  • Keep it vendor-neutral. MCP is an open standard. Build for any agent, not for one assistant.

For a long time, "who is our user?" had one answer. Now it has two. The companies that design for both will decide how agents use their products, instead of finding out afterwards.

Want to dig into this?

If any of this is a problem you're facing right now, I'm happy to talk it through.