The operator in the middle

Here is the shift, stated plainly: you no longer have to build every feature yourself. For years the instinct in software has been to add more. More connections, more modules, more boxes ticked on a comparison table. MCP turns that instinct on its head. It lets you do one thing brilliantly, and lets everything else be done brilliantly by somebody else.

Doris books rooms. That is the whole job, and we would rather do it simply and well than bolt on a mediocre accounts package because a feature list said we should. QuickBooks and Xero do accounts properly. Mailchimp does the mailing list. Stripe moves the money. The old world made you the glue between all of them. The new one hands that job to an assistant you already pay for.

The operator used to be you

For years, the real integration layer in most organisations has been a person. You, probably. Or whoever does the admin on a Tuesday evening.

The calendar knows who booked what. The accounting software knows who has been invoiced. The inbox is where the chasing happens. None of them talk to each other, so somebody sits in the middle, reading one screen and typing into the next. Copy the booking, paste it into the invoice. Check who has paid, tick them off. Open the mail, write the reminder. It is not hard work. It is just relentless, and it is the first thing to slip when the week gets away from you.

That middle seat, the wiring between your tools, is the thing that is quietly changing. The change has a clumsy name: MCP.

What MCP actually is

MCP stands for Model Context Protocol. Ignore the words for a moment; here is the idea.

Software has always been able to talk to other software, but only through bespoke wiring. If you wanted your booking tool to talk to your accounts, someone had to build a specific bridge between those two specific products. Ten tools meant a tangle of one-off bridges, most of which nobody ever built, which is precisely why you ended up doing the copying by hand.

MCP is an agreed shape for that socket. Instead of every tool needing a custom wire to every other tool, each tool exposes one standard connector. And an AI assistant, Claude or ChatGPT, plugs into all of them at once and becomes the operator in the middle.

That is the part worth sitting with. The operator is not a passive junction box. It listens to a plain-English instruction, works out which tools it needs, and moves between them. Ask it to find last month's unpaid bookings and draft a reminder to each, and it touches the calendar, the accounts and the mailbox in a single sentence, and you never told it how. It is the switchboard operator of the old telephone exchange: you say who you want, and they connect the line. Which is to say it is a job a person used to do.

One connector is a party trick. Five is a different animal.

A single connector is mildly useful. The assistant can read your calendar, say. Nice, not life-changing.

The shift happens when several are plugged in together: mail, accounts, a payment tool, a mailing list, your booking system. Now the operator can carry a task across all of them in one pass, and, this is the part that surprised us when it clicked, it reshapes itself to each request. Monday it reconciles the month. Tuesday it drafts a newsletter from who attended what. Thursday it tells you which room is quietly losing you money. You did not build three workflows. You described three, in ordinary English, and the same operator handled each.

This is why it reads as a multiplier rather than a feature. A £20-a-month subscription to Claude or ChatGPT, with the connectors included, becomes leverage across every tool you own. You are not buying one more app. You are buying the thing that makes all your other apps work together.

The ecosystem you can actually reach

There is already a growing catalogue of these connectors: mail, calendars, accounting packages, spreadsheets, file storage, mailing tools. And because MCP is an open standard, anyone with a product and an API can publish their own. That last point matters more than it sounds: the tools you already pay for can take a seat at the switchboard without waiting for some big integration deal to be struck on your behalf.

A note on honesty, because it saves disappointment later. The assistant that does this is an ordinary paid subscription, about £20 a month, with the connectors included. It works when you ask it to, not around the clock, and a heavy day's use can run into the subscription's limits like anything else. So it is a diligent assistant that keeps your hours, not a tireless robot working the night shift. Set that expectation correctly and the thing is a quiet pleasure to use.

Why we did not just build the plugs ourselves

The obvious move, when you are building a tool like Doris, is to build the connections yourself. Wire Doris straight into QuickBooks, into Xero, into Mailchimp. Tick the boxes on the feature list. Plenty of software does exactly that.

We looked at it, and then we looked at what it actually costs, not to build, but to keep alive. Every one of those connections is a pipe you now own forever. When QuickBooks changes something at their end, your pipe breaks. The customer does not ring QuickBooks; they ring you, because in their world it is Doris that stopped working. So you drop what you were doing, re-engineer the pipe, and ship a fix. Multiply that by every integration on the list, across every provider's release schedule, and you have quietly signed up to a treadmill that never stops. That cost does not disappear. It lands in the price your customers pay.

MCP rearranges who owns what. Instead of Doris building and babysitting a dozen brittle pipes, Doris maintains exactly one connector: its own edge, which we control and version. Everyone else maintains theirs. The operator in the middle does the joining, in language rather than hard-wired field mappings, so when something shifts on one side it tends to adapt rather than snap. Doris stops being the single point that breaks and gets blamed for the whole chain.

We will be straight about the edge of this: it works cleanly where the other tools publish their own connectors, and that ecosystem is still filling in. Where a provider has not yet, someone still has to bridge the gap, but that someone no longer has to be us, and it is not a pipe we are on the hook to keep alive for the life of the product. We build our own edge well, and let the rest of the switchboard be somebody else's job. Which, if you have read this far, is a very Doris way to behave.

Where Doris sits: the well-behaved node

Doris is a room-booking tool: your people, your rooms, whether that is two rooms or a hundred. The architecture does not change with size, so scale is not the part worth dwelling on. This is: Doris ships a native MCP connector, and it can take its seat at the switchboard the day you plug it in.

That is still an unusual thing for a booking tool to offer. The hospitality world has been racing to expose hotel inventory outward, so a traveller can book a room through an AI assistant. Doris's connector points the other way, inward, handing your own back-office assistant the bookings, the utilisation and the statements it needs to reconcile and chase. A connector built for the operator rather than the public is, as far as we can tell, early ground for a booking tool.

What it puts on the table is mostly reads: your bookings, your room utilisation and what each room has earned, and your statements, the invoices raised to your members. It can also prepare: generate this month's statements, and, when your accounts confirm a payment has landed, suggest which invoice it settles. What it cannot do is commit the change that matters. Marking an invoice paid is a guarded action a person takes inside Doris. The assistant can propose the match, but the flip to paid is not a lever it holds.

That boundary is not an accident of how far we have built; it is the whole design. The assistant works right up to the point of consequence and no further. It prepares and suggests, and the irreversible step waits for you. And Doris still holds no tool to take the payment at all: money moves through your own accountant and payment tool, never through Doris. The report, and now the suggestion, is the edge. Doris does its job, keeps the diary honest, tells you what is owed, drafts what it safely can, publishes that cleanly, and leaves the deciding to you.

What that lets you start doing

Once Doris is a node on your switchboard, the instructions get quite ordinary, which is the point:

• Which of last month's bookings have not been settled? Draft a gentle reminder to each, in my usual tone, and leave them in my drafts.
• Take this month's statements and draft the matching invoices in my accounting software for me to check.
• Before I renew the lease, show me which rooms ran below half capacity this quarter.
• Split last month's hours into the sessions we charge for and the ones we don't, and give me the totals.

Notice where every one of those ends. In a draft. On a summary. On something you look at before anything leaves the building.

The rule that makes it safe: everything in pencil

This is the part we would refuse to skip, because handing one operator the keys to your mail, your accounts and your payments is exactly as consequential as it sounds. An assistant reading your inbox is also reading whatever a stranger put in your inbox, and an instruction hidden in an email, telling it to forward the invoices to some address, is a real risk, not a thought experiment. The platform vendors say as much themselves: a connector can take action in services nobody has vetted, and you should treat that seriously.

The discipline that answers it is simple to state, and worth making a house rule: the operator works in pencil. It reads, it reasons, it drafts, and then it stops. The reminder sits in drafts until you send it. The invoice waits in the accounts package until you approve it. The human keeps the one action that cannot be undone: pressing the button. You get the speed of the switchboard and keep the judgement for yourself.

There is a sharper version of that rule, and it is the one to hold onto when you decide what to plug in, because connectors are not all built the same. Some are designed to draft; some are designed to fire. A well-made connector's most powerful tool leaves something for you to check: a message in your drafts, an invoice pending your approval. It keeps the irreversible step out of the assistant's reach altogether. A careless one hands the operator a live send and hopes everyone downstream stays alert.

So when you are choosing what to give the switchboard, ask it of each tool in turn: does this draft, or does it fire? Prefer the ones that draft. Doris, from earlier, is one of them on purpose: it will show you exactly what is owed, and there is no tool anywhere in it to move the money.

The best safety is not you remembering to be careful; it is the tool never being able to do the dangerous thing in the first place. The pencil rule is easiest to keep when the tools themselves are already holding a pencil.

The honest economics

The tidy version of this story is that you replace your £40,000 administrator with a £20 subscription, and we do not think that is true, so we will not sell it to you. A good administrator does forty things, most of them judgement, relationships, and being in the room. What the switchboard genuinely takes off the table is the tedious, rules-based slice of that job: the reconciling, the chasing, the retyping of what one system already knows into another. That slice is real, it eats your evenings, and handing it over for the price of a subscription (plus VAT, as ever) is a straightforwardly good trade.

You stop being the wire between your own tools. Doris keeps the diary honest and publishes what it knows. The operator carries it the last few steps, in pencil. And you get your Tuesday evenings back.