[ PRODUCT LEADER · AI STRATEGY · MELBOURNE ]
[ ← WORDS ]

[ MCP · AI · PRODUCT ]

MCP vs in-product AI: where should a job live?

When a customer wants an AI to work with your product's data, should the job be served by an MCP server in the assistant they already use, or by AI inside your product? A working test, and why the line probably runs along consequence, not surface.

When a customer wants an AI to do something with your product's data, who should serve it? An MCP server inside the assistant they already use, or an AI feature inside your own product?

Most of the debate I hear frames this as chat inside the product versus chat outside it. I think that's the wrong comparison. The sharper question is whether a job belongs outside the product at all. "Should this live in MCP?" is a different, and more useful, conversation from "which chatbot is better?"

This is my working answer. I'll flag clearly where it's a hypothesis, because most of it is.

Why the question is live now

Customers are already starting in AI tools, and the ground has firmed up under MCP. In December 2025 Anthropic donated the protocol to the Agentic AI Foundation, a directed fund under the Linux Foundation, co-founded with Block and OpenAI. That doesn't make it right for every product, but it does make it harder to treat as a passing experiment.

The company that has gone furthest is Atlassian, so it's a useful reference. Its own posts put daily volume at more than 5 million tool calls in July, and more than 15 million calls a day by October, when it rebuilt its server with 220+ tools that it says use up to 25% fewer tokens on the same work. The company also says 44% of its MCP users aren't on software teams. All of that is self-reported, and the two volume figures are counted slightly differently, so I'd read them as direction, not precision.

The framing from outside the Atlassian world is similar. DeepL's team argues that the product is better understood as a set of capabilities than as an interface, and that what changes is "the number of places a customer can reach your capabilities." Their version of the split is that the assistant handles reasoning and orchestration while the specialist system does the work it's good at. That article ends by promoting DeepL's own MCP server, so it's a vendor's view, but it's a useful way to put the question.

What's moved in MCP this year

The protocol itself has changed a lot in twelve months, and most of it points the same way: towards something you could run a real business on.

  • November 2025: a Tasks primitive for long-running work shipped as experimental.
  • January 2026: MCP Apps arrived, letting a tool return interactive UI rendered in a sandbox inside the assistant. That blurs the line between "outside the product" and "a piece of the product, shown elsewhere".
  • April 2026: the first MCP Dev Summit in New York, run by the Agentic AI Foundation, drew roughly 1,200 people. One theme, as reported by a conference write-up, was a central gateway and registry as the control plane, with writes handled in deterministic infrastructure instead of the model's reasoning, and least-privilege access enforced at the gateway. A second summit followed in Bengaluru in June.
  • 28 July 2026: the largest spec revision since launch. Requests became stateless, so servers scale behind an ordinary load balancer. Authorisation was tightened. Tasks became a proper extension. A multi round-trip mechanism lets a tool stop mid-call and ask the client for input, which is the obvious way to build "confirm before I create this" into a tool.

I'd read that as a protocol growing up around governance. The parts getting attention are the ones that matter for writes: who is calling, with what permission, and where the confirmation happens.

The other half: customers don't need your connector

Everything above is about you choosing to show up in someone else's assistant. The bigger shift is that assistants are now showing up in your customers' lives without waiting for you.

The first wave was open source and asked a fair bit of its users. OpenClaw, an always-on agent you reach through apps like WhatsApp and Telegram, took off in early 2026 and had security problems at launch. Nous Research's Hermes Agent followed in February and, by mid-year, was passing OpenClaw on OpenRouter's ranking of agents by daily token use. Those were things you ran yourself, and mostly technical people did.

Then the big platforms arrived with consumer versions. Meta's Muse launched on 8 September, rolling out in the US first and since reaching Australia, and Meta says anyone can use it "out of the box, no technical experience required". It runs on its own cloud computer, sends emails, books travel, fills in forms and checks out through a one-time card, and Meta says it checks with you before sensitive actions like sending or buying. OpenAI's dots followed on 29 September, an always-on agent that can connect to more than 4,000 apps and has a read-only mode for when you're away. Anthropic's Claude Duet came in late October as a research preview for Pro and Max subscribers, aimed at professionals and small business owners, with a morning brief and a check-in before important actions. xAI's Grok Bot, in beta since 11 August, sits slightly apart: it's pitched at teams more than individuals, but it's built around the same idea of an agent with its own computer.

Every one of those descriptions is a vendor's own claim, and I haven't tested any of them. But the common pattern matters more than any single product. They work in the same apps, inboxes and browser tabs a person would, and xAI says outright that Grok Bot works with tools that have no clean API or MCP integration. Reliable connectors are better for you and for the customer. A browser agent with someone's login doesn't need one.

For the question in this post, that does two things. First, "should this job live in MCP or in the product?" is no longer the full menu, because a third option exists that you don't control: the customer's own agent, using your screen. Second, the platforms are building the consequence gates themselves, with one-time cards, read-only modes and checks before sensitive steps. That's worth knowing before you decide how much of your own approval design to push outside your product.

How much people want to hold on to

The personal agents above are one example of a question that's been running in developer tools for a couple of years: how much of what the AI does do you want to watch? If you were an early adopter of AI coding tools, you've lived the answer changing. First came tab suggestions and completion: the AI proposes a line, you press a key. Then agents you drove step by step, approving each command and each edit. Then auto mode and loops, where you hand over a task, let it run, and come back to review the result. Customers of other software haven't been through that arc yet.

Two public data points show how fast the appetite moved, and what it did to review. Cursor's Michael Truell wrote in February that in March 2025 the product had about 2.5 times as many Tab users as agent users, and that the ratio had since flipped to roughly two agent users for every Tab user. Cursor's own claim is that more than a third of the pull requests it merges internally now come from agents running autonomously on their own machines. That's a vendor describing its own usage, so it's direction, not a benchmark.

The more useful lesson is about approval. Anthropic's engineering post on Claude Code's auto mode, in March, says users were accepting 93% of permission prompts anyway, which it calls approval fatigue: people stop paying attention to what they're approving. Its answer was to let a classifier approve routine actions and escalate the risky ones to a human. It also reports a 17% miss rate on real risky actions in its own testing, and says plainly that auto mode isn't a replacement for careful review on high-stakes work.

So the dial between holding on and letting go isn't fixed, and people keep turning it towards letting go once the routine steps have proved boring. That's the same shape as the line I keep coming back to. Routine, reversible work gets handed over fast, because a human approving every step stops being a control and turns into a click. The steps that move money or can't be undone are where a person still has to actually look. Customers of other software will turn that dial too, probably in less time than developers did, and the products that treat approval as a design problem, not a pop-up, will be the ones that hold up when they do.

A test, offered as a hypothesis

Here's the rough sorting I'd start with. Treat it as something to disprove.

MCP first when the job is:

  • A question or analysis on your data, such as a P&L, balances or invoice totals
  • Open-ended or specific to one customer, so a one-size-fits-all build would be slow
  • Better when combined with other tools the customer already uses
  • A single question with a single answer, not a process with steps

In-product when the job:

  • Is a multi-step workflow
  • Needs a file or document upload
  • Needs the customer to see and approve something first
  • Is faster by hand than by chat
A test for where an AI job should liveA flow of four questions. If the customer needs to see and approve something first, needs an upload or standard flow, or the job is a multi-step workflow faster by hand, it belongs in the product's own AI. If it is a single open-ended question that improves with other tools, serve it through MCP first. Otherwise default to in-product and watch what customers do outside.Working hypothesisDoes the customer need to see andapprove something before it happens?Does it need a file or documentupload, or a standard flow?Is it a multi-step workflow, or fasterto do by hand than by chat?Is it a single open-ended questionthat gets better with other tools?nonononoyesyesyesyesIn-product AIthe screen, the upload and theapproval live where you control themMCP firstDefault to in-product, and watchwhat customers do outside it
The test as a flow. The default for anything unclear is in-product, and you watch what customers do outside it.

A worked contrast

Take a periodic tax filing. It means working through documents and reviewing the result before it goes anywhere. Dragging that into a third-party chat is a poor experience, so the workflow stays in the product. The in-product AI still has a role inside it, explaining what's on screen or answering questions about the data while the customer works.

Now take "what's my true profit?" or "how's my cash position?" These are single questions with a single answer, and the value comes from combining your numbers with whatever else the customer has. They suit MCP well.

Two more that I'd have kept in-product: approving bank feed transactions, because the customer needs to see them before confirming, and document extraction, because it needs a standard flow. I'm less sure of both now, and the next section is why.

Where the test is probably wrong

I've been talking to customers who already use AI heavily with their accounting data, and they cut against half of my in-product list. It's a small group, and they were picked because they're early adopters, so this tells me what AI-native customers do, not what most customers do. But it's enough to change my mind about the shape of the line.

Several already run multi-step workflows through agents outside the product. A few have agents handling supplier bills and receipts. And the "customer needs to see it first" test turns out to be about review, not about your screen. People check a report, a screenshot or an activity feed, or let the agent run and only look when it stops on a mismatch or something new. Your screen is one way to review. It isn't the only one.

What they do hold back is more consistent. Money leaving the business, and changes to bank details, are where they stop. Nobody I spoke to wanted an agent paying bills. So my current guess is that the real line is closer to consequence and reversibility than to surface. A reversible change that's easy to review, like a draft, a coding suggestion or a match, can live outside the product. A payment can't be unsent. I'd treat that as a better hypothesis than the four-question flow above, and the diagram is the earlier, cruder version of it.

Go after workflows, not tools

My hunch is that people arrive at MCP with a specific, painful job, a report that takes too long or constant copying between tools, and not out of curiosity about the tool. If that's right, a list of tools is the wrong way to present yourself. Lead with named workflows in the customer's own context, and treat single-question lookups as the entry point, not the destination.

I can't point to solid evidence for this in my own market. Atlassian says retention is up in every cohort, without publishing a number, and doesn't tie it to a particular kind of use. So this is a thing to test with your own customers and your own usage data, not a finding to borrow.

The second consequence is that you don't have to build every workflow yourself. In-product AI can only cover the jobs you have time to build. With MCP, customers can combine your data with their own tools and prompts to produce analysis you'd never have prioritised. A cross-customer industry benchmark is a year-long project if you build it. A customer with a research prompt and their own numbers can get something similar this afternoon. Your job becomes making the data they bring complete, accurate and trustworthy.

That's also where the investment seems to go at the companies furthest along. Atlassian's posts emphasise a context layer and governance (permissions respected, admin control over which clients can connect, audit visibility) more than tool count. For most teams, the thing worth building is data that's correct and permissioned, behind tools that are narrow and well described.

Writes are the open question

About a third of Atlassian's MCP calls are writes. So at least one big vendor has clearly decided agents will change data through MCP. Whether your customers want that, and on what terms, is a separate question.

The customers I've spoken to have already made the decision for you in some cases. Several of the heaviest users do writes today by pointing a browser agent at the product's screen, and they complain about the cost: tokens, slow pages, repeated two-factor prompts. They'd rather the writes went through a proper connector. That's a small, self-selected group, but it suggests that if you don't offer writes, some customers will route around you with something less controlled.

My instinct is that people hand over reads easily and want to verify writes, and that the bar for writes is reversibility: drafts, coding and matching with review by exception, and nothing that pays or changes bank details. I'd treat that as an assumption to test, not a finding. The harder problem is the one from my post on human in the loop: when the agent runs in someone else's interface, where does your gate sit? An assistant that chases every overdue invoice at scale is a very different thing from one that answers a question. If you don't own the screen, you have to build the approval into the tool itself.

Contentstack's Tim Benniks makes a version of this argument from the platform side: work is spreading across browser assistants, coding agents and custom agents, so reach can live outside the product, but "trust still needs a home." He likens MCP to a USB port and the governed platform to the operating system that decides who connects and what they can do. It's a vendor blog with no data behind it, but the instinct matches mine. Let the reach go outward, and keep permissions, approvals and audit somewhere you control.

I'd still watch what customers do without you, through browser agents and the personal agents above that need no connector from your side. Whatever they take outside the product on their own tells you more about where the line sits than any framework I can draw. If you've drawn this line in your own product, I'd like to know which job surprised you by landing on the wrong side.

[ GET IN TOUCH ]

Like what you’re reading?

I’m always up for a conversation about AI products, evals, or whatever you’re building.

[ SAY HELLO ↗ ]

[ MORE TO READ ]

  1. 01Human in the loop is not a buttonMost "human in the loop" designs are a confirmation dialog bolted on after the write. Here is what it takes to build approval into an agent properly: gates, evidence, reversibility and the slow, human parts.[ AI · AGENTS · PRODUCT ]18 November 2026 · 13 min read
  2. 02What I'd tell the next PM on an AI teamLessons from leading an agentic chat product inside an accounting platform: learn faster than you build, put legal and safety inside the harness, back your engineers' experiments, and be strict about the evidence even when you're loose about the code.[ PRODUCT · AI · AGENTS ]1 November 2026 · 7 min read