MCP (the "Model Context Protocol") is the open standard that lets an AI agent reach into your tools and data. It's powerful — and easy to over-apply. Here's where it earns its complexity, and where a plain, predictable workflow wins, especially in a precision-driven business.
A simple way to tell agent work from automation, before you build anything.
Closing the books, processing invoices, running payroll — that's execution. Same inputs must produce the same outputs, every time. AI can be a step inside (classify, summarize, draft), but it shouldn't run the show. MCP fits open-ended work instead: research across many sources, "what did we spend last week," comparing terms against actuals — where the path through the data isn't fixed.
Most of what feels like it "needs an agent" turns out to be a workflow nobody has mapped yet. Once it's mapped, plain automation handles it more reliably and more cheaply than an agent could. In a typical backlog, only a handful of use cases are genuine MCP territory — the rest are workflows or simple scripts.
When MCP is the right answer, the wrapper itself is only about 20% of the work. The other 80% is the integration behind it, the agent design that uses it, the accuracy guardrails, and the human-review patterns that make it safe for production.
If yes — you can name the trigger, the data, the rules, and the output before you start — it's automation. Build it once and it runs the same way every time. If the honest answer is "the agent will figure it out," it's agent territory — and that flexibility had better be worth the added latency, cost, and unpredictability.
When we read a list of AI ideas, the split is usually lopsided — and that's a feature, not a disappointment.
Open-ended research, knowledge retrieval across messy sources, reviewing documents where the question changes each time, an evolving Q&A interface. Worth the complexity because the path isn't fixed.
The repeating, precision tasks — the ones you could draw as a flowchart. Faster to deliver, cheaper to run, and far more reliable, with AI used inside them where it adds value.
MCP arrived in late 2024 with a clean pitch: one universal way to plug any tool into any AI, so you stop building a custom integration for every app. The major players adopted it fast, and the promise is real — but so are the growing pains.
Connect a tool through MCP and any MCP-aware assistant can use it — no more one-off integrations for each AI client. For a single, quick request, it works beautifully.
The moment the work runs long, or an assistant fires several tool calls in one conversation, today's MCP exposes reliability gaps. It's terrific for the simple case, and still maturing for everything else.
None of these are reasons to avoid AI. They're reasons careful teams are deliberate about where they lean on MCP today.
MCP was designed around fast "ask and reply" calls. Anything that takes a while — a big query, a multi-step job — holds the line open the whole time. One network blip and the work finishes on the server, but the assistant has stopped listening. You see it hang forever.
Each AI client gives up waiting at a different point, and those limits aren't published. A tool that's reliable in one assistant quietly fails in another simply because the second stopped waiting sooner — with no way for you to tell it to wait longer.
When an assistant makes several tool calls in one conversation, they share a single connection. Many of today's servers have edge cases there — a reply gets matched to the wrong request, or dropped entirely. Real agents call several tools per turn, so this comes up more than the original design expected.
The people who maintain MCP know about these gaps, and the structural fixes are landing fast.
Late 2025 added tasks — a clean way to hand off long-running work: the assistant gets a ticket, the tool takes the time it needs, and they reconnect when it's done. That kills the "it hung forever" problem. And MCP gateways now add security and rate limits in front of any server.
For production work with a known set of tools, we often skip MCP and let the AI call those tools directly — which the major platforms support natively. It isn't a workaround; it's what most serious production systems run, every step visible in your own logs. When MCP matures, switching back is trivial.
Give us your list and we'll mark which are genuine agent work and which are workflows nobody has mapped yet — usually a short session is enough to find the few worth building first.