Build an MCP server only if you need external AI agents — Claude, ChatGPT, Cursor, or a customer's internal agent stack — to call your product directly and take real actions on a user's behalf. If you just want your own product to have an AI feature, you don't need MCP at all; you need a normal integration with an LLM API, which is a different and usually cheaper project.
Model Context Protocol (MCP) is the open standard Anthropic published for connecting AI agents to external tools and data sources (spec and docs). It's gained real traction fast — OpenAI, Google, and most agent frameworks now support it — which is why it's showing up in founder roadmaps this year. But "the industry adopted a standard" and "we should build one" are different questions, and we're seeing teams skip straight past the second one.
What an MCP server actually does
An MCP server is a thin adapter. It exposes a fixed set of your product's actions and data — "create an invoice," "look up a customer's order status," "schedule a shipment" — as callable tools, described in a schema an agent can read and reason about. The agent (running in Claude, a custom app, whatever) discovers your tools, decides which one to call, and gets structured results back.
Under the hood, it's still your existing API or database being called. MCP doesn't give you new capabilities — it gives external agents a standard, discoverable way to reach capabilities you already have. That's the whole value proposition: instead of building a bespoke integration for every agent platform your customers use, you build one server and every MCP-compatible agent can talk to it.
Who actually needs one right now
We ran into this exact decision with our own outreach engine — the tool we mention below that scrapes a prospect's site and drafts a cold email. A customer asked whether they could point their internal agent stack at it directly instead of going through our UI. That question is the entire test: someone with their own agent already running wants to call your product as a tool, not a website. Three situations where that's a real requirement, not a nice-to-have:
- You sell to technical buyers who run their own agent stacks. If your customers are already wiring Claude or internal agents into their workflows and asking "can we connect to your API from our agent," an MCP server is the difference between a same-week yes and a custom integration quote.
- Your product is itself an agent-orchestration layer and you need to expose sub-tools to a supervising agent — this overlaps heavily with the tradeoffs in agents vs. workflows: if a fixed workflow would do, you don't need agent-callable tools at all.
- You're building a developer platform where "AI-native integration" is part of the pitch, not an afterthought.
If none of those describe you, an MCP server is a solution looking for a problem. Most SaaS products get more near-term value from a solid, versioned REST API with an OpenAPI spec — which almost every agent framework can already consume as tools without you writing an MCP layer at all.
The real cost of building one
For a product with five to ten core actions, building an MCP server is closer in scope to a focused API-integration project than a platform rewrite — usually a few weeks for one engineer, assuming the underlying logic already exists and is reasonably clean. Tool design is the part that actually eats the schedule, not the protocol itself — the same lesson we learned collapsing our outreach engine's two-step "extract facts, then draft email" flow into one call, below: deciding what to expose and at what granularity takes longer than writing the adapter code. The work breaks down into:
- Tool design — deciding which actions to expose and at what granularity. This is the part teams underestimate.
- Schema and validation — strict input/output schemas so the agent gets predictable errors instead of silent failures.
- Auth and scoping — an agent acting on behalf of a user needs the same permission boundaries a human session would get, not broader ones.
- Observability — logging every tool call with enough context to debug "why did the agent do that," because you will need it.
The cost isn't the protocol — it's the same discipline you'd want in any API you expose to a third party, plus the added surface area of something non-deterministic (an LLM) deciding when to call it.
The failure mode: too many tools, too granular
The most common mistake is treating MCP tool design like REST endpoint design — one tool per database table, one per CRUD operation. That gives an agent 40 narrow tools to choose between, which tanks both accuracy and latency, since the model has to reason about which of many similar-looking tools applies.
We hit a version of this problem building our own outreach engine, which scrapes a prospect's site and drafts a tailored cold email. Early versions split that into separate "extract facts" and "draft email" steps, calling the model twice. Collapsing it into a single call that did both, with the extraction as an intermediate output inside one prompt, beat the two-step chain on both cost and quality — fewer round trips meant less compounding error. The same principle applies to MCP tools: fewer, higher-level tools ("find_and_summarize_customer," not "get_customer" plus "get_orders" plus "get_notes") give the agent less surface area to get wrong. This is the same tradeoff we cover in single-call vs. agent chains — it applies just as much to tool design as to prompt design.
When to skip it entirely
Skip MCP if:
- Your only goal is an in-product AI feature (chatbot, search, summarization) — that's a direct LLM API integration, and the cost considerations look more like LLM cost optimization than protocol design.
- No customer or partner has actually asked for agent access — build the REST API well, and add an MCP layer later if demand shows up. It's a thin wrapper you can add without re-architecting anything.
- You're choosing between a custom agent and an off-the-shelf chatbot platform for a single use case — that decision, covered in custom AI agent vs. chatbot platform, usually resolves before MCP even becomes relevant.
A pragmatic rollout path
Start by exposing your existing API as an OpenAPI spec, if it isn't already — most agent frameworks can consume that directly as tools with no MCP involved. If you see real demand from customers who specifically want MCP compatibility (increasingly common in enterprise procurement conversations), wrap three to five of your highest-value actions as an MCP server, instrument it well, and expand based on what agents actually call — not what seems complete on paper.
MCP is a real standard worth having on the roadmap if agent-driven integration is core to how your customers will use your product. It's not a checkbox to add to every SaaS product this quarter.
If you're trying to figure out whether your product needs one — or need help scoping and building it right — let's talk.
Originally published on the Pykero blog.
