MCP: Model Context Protocol one standard instead of an integration per model
MCP is a shared way of plugging an AI agent into your company tools and data. Instead of writing a separate connector for every model, you expose a system once and any application that speaks the standard connects to it. Below: the explanation without code, the difference against a plain API integration, what it does to cost, and the limits worth knowing before you let an agent into a system.
- 2024the year Anthropic published MCP as an open standard, independent of the model provider
- 1 serverthat is all one data source needs for any application that speaks the standard to connect to it
- EUR 0.005 to 0.07the cost of a single query to the model, paid to the provider directly; the standard itself has no licence
- EUR 3,500 netone week of the process workshop, where we decide which sources are worth connecting at all
Short answer
What is MCP (Model Context Protocol)?
MCP is an open standard published by Anthropic in 2024. It describes how an application running a language model connects to a server that exposes tools and data to it. Think of a socket with a known shape: you do not build an adapter for every device, you fit the socket once and the plug fits.
For an owner it comes down to one thing. You expose your system, a CRM or the sheets holding sales data, once. After that any AI agent that speaks the standard can connect to it. Changing model provider stops meaning a rewrite, because the integration sits on your side of the wire, not on the model's.
Not everyone needs it. If you have one repeatable flow that always looks the same, a plain automation in Make or n8n does the job cheaper. MCP starts to make sense when the questions are unpredictable and the answer has to be assembled from several systems at once.
How is MCP different from a plain API integration?
An API integration joins two specific points: your system and one application. It works well until something changes. Swap the model or swap the application and the connector gets written again, because it was built for that one case.
MCP flips the order. You describe once what your system can show and what it can do, and anything that speaks the standard can stand on the other side. The same thing in a table below, together with the options that need no model at all.
| How you connect | What you redo when the model or the app changes | When it makes sense |
|---|---|---|
| Integration written for one model | you write it again, it was built for that one case | one source and one flow that does not change |
| Plug-in for one product | nothing carries over, outside that product the plug-in does not exist | you use a single tool and plan no change |
| A server that speaks MCP | you point the new application at the same server | several sources, several applications, questions you cannot list up front |
| A scenario in Make or n8n | nothing, there is no model inside it | a fixed flow with a trigger and known steps |
| Pasting data into a chat by hand | nothing, but you redo it for every question | a one-off question on data you do not need to protect |
The table compares ways of connecting, not the quality of answers. The model on the other side will be exactly as good or exactly as bad whether the data arrived over MCP or over a connector somebody wrote by hand.
What does MCP change in cost and timeline?
The standard is not a product, so it has no price list. You pay for the same things every integration costs: access to the system, deciding what may be read out of it, mapping the data, testing and maintenance. The saving shows up later, on the second and the third source.
The first connection is the expensive one, because that is where you settle the questions that then apply everywhere: who gets access, what stays in the log, what happens when something fails. The next source drops into a layout that already exists. That first connection is most of the work in our AI integration services, and the workshop is where those questions get settled.
- The standard itself carries no licence: it is a description of how to connect, not software you subscribe to
- Model usage is a separate bill: EUR 0.005 to 0.07 per query, paid to the provider directly
- The first source costs the most, because that is where permissions, data scope and write rules get decided
- The process workshop costs EUR 3,500 net per week, 1 to 7 weeks, and ends with a list of the sources actually worth connecting
- The build is quoted after the workshop, because the price depends on how many systems there are and what state their data is in
How do you connect the first data source over MCP?
The order is always the same, and it starts with questions rather than systems. This is how we run it: workshop, pilot on real data, production, measurement after 30 days and after 90 days.
Write down the questions, not the systems
Take twenty questions that came up on Slack or by email last month and needed somebody to open a system. Which source goes first follows from those, not from an architecture diagram.
One source, read only
The first connection is read only. The agent reads and answers, it changes nothing. That is the cheapest way to find out whether the data is fit to answer the question at all.
Pilot on real data with a narrow group
A handful of people who ask those questions daily. We collect the wrong answers and the ones where the agent could not point at a source. Then we fix the data or the access scope, not the wording of the instructions.
Production, measurement, then the second source
After 30 days and after 90 days we compare against the number from before the start: how many questions the agent handled alone, how many went to a person. The second source goes in only once the first one holds up.
What permissions should an agent get, and what stays in the audit trail?
MCP brings no permission model of its own. Your system still decides what the account the agent connects with is allowed to see. That makes the access conversation a conversation with the system owner on your side, not with the person wiring up the connection.
The second thing is the trail. If everyone asks through one technical account with full rights, the system log shows one account and nothing else. A month later nobody can reconstruct who asked what.
- A separate technical account for the agent in every system, with narrower rights than an administrator
- Reads split from writes: the agent reads from day one, it writes only after the pilot
- The data scope is set by the system owner, not by whoever configures the connection
- A log of calls in a place you can reach without asking the vendor
- Every answer points at its source, so a number can be checked back to where it came from
Access to a tool is not permission to act
This is the trap that costs the most and is the easiest to walk into. Connecting a system over MCP gives the agent the ability to perform an operation. It does not settle whether the agent may perform it without asking a person. Those are two separate decisions and only the first one is technical.
The working rule looks like this: reading goes through without confirmation, a write into a production system always waits for one. Issuing an invoice, sending an email to a customer, moving a deal stage in the CRM, repricing a product in the shop: the agent prepares, a person clicks. Only after a few weeks of faultless proposals is it worth taking the confirmation off one narrowly described operation.
When is MCP not the answer?
The most common bad reason to adopt it is that the topic is new and somebody wants to have it. The standard solves a specific problem: many sources, many applications, questions nobody can write down in advance. Outside that shape, simpler tools win on price and on time.
If your data sits in files with no owner and nobody knows which version is current, connecting an agent fixes none of it. Tidying the sources is a separate job, and we wrote it up in the guide on how to build an AI knowledge base.
- One flow with a clear trigger and fixed steps: a scenario in Make or n8n does it cheaper and with no model inside
- One source and one question asked once a month: a report or a saved view in the system is enough
- Data scattered across files with no owner: order first, access second
- A process nobody in the company can describe step by step: the agent will freeze the mess in place instead of clearing it
Does MCP reduce lock-in to one model provider?
Partly, and it is worth knowing which part. The work you do while connecting a system stays on your side: the technical account, the data scope, the write rules, the log. That layer does not disappear when you change model, because it was never written around one model's habits.
What does not disappear is the dependency on the quality of the model itself. A different model reads instructions differently and picks tools differently, so after a swap the answers have to be tested again. The standard shortens the move, it does not make it for you. Our BOND company AI agent answers from company data in 5 to 10 seconds, and that is the part we measure regardless of which model sits underneath.
Common mistakes
Five mistakes when connecting an agent to company systems
Write rights from day one
The first week usually produces the worst answers, because the data and the access scope are still off. An agent with write rights bakes those mistakes into the system instead of showing them to you.
One technical account with full rights for everybody
The system log shows one account and nothing else. When you need to reconstruct who asked what and where a wrong number came from, there is nothing to read.
Connecting every system at once
When an answer is wrong, nobody knows which source broke it. Diagnosis takes longer than the build did, and the team stops trusting the tool while it drags on.
Treating the standard as a substitute for tidy data
The agent gets access to three versions of the same sheet and answers from whichever it found first. The answer is fast and untrue.
Choosing MCP where an automation scenario would do
You pay for flexibility nobody uses, and a simple flow becomes harder to maintain than it was before.
Checklist
Checklist before you connect the first system
If any line is a no, do not start with the connection.
- You have a list of real questions from the last month that the agent is meant to answer
- Every source has an owner on your side who says what may be read from it
- The first connection is read only
- The agent has its own technical account, not administrator rights
- Every write into a production system needs a person to confirm it
- The log of questions and calls lands somewhere you can reach without asking the vendor
- You know what one query to the model costs and who pays that bill
- You have written down what has to happen when the model provider changes
Let us see what is worth connecting
Process first. Tools second.
On a free 30-minute consultation we take your questions from the last month and say plainly whether you need an agent wired into your systems or a scenario in Make or n8n. The process workshop costs EUR 3,500 net per week and ends with a process map and the sources listed in the order you should connect them. We run at most two implementations at a time, so we say no when the queue is full.
Book a free consultationFrequently asked questions
What is MCP (Model Context Protocol)?
An open standard published by Anthropic in 2024. It describes how an application running a language model connects to a server that exposes tools and data to it. You expose a company system once, and any application that speaks the standard can connect to it.
Does MCP only work with Anthropic models?
No. The standard is open and independent of the model provider, and different client applications support it. Anthropic published it but does not control who uses it. That is the main reason the standard is worth paying attention to at all.
How is MCP different from Make, n8n and Zapier?
Make, n8n and Zapier run a flow you designed up front: an event happens, the steps execute. MCP gives an agent access to tools and lets the agent decide which one to reach for on a given question. Pick a scenario for a fixed flow, an agent for questions you cannot predict.
Is MCP safe for company data?
The standard itself changes nothing about your security level, because it brings no permissions of its own. Safety depends on the rights the agent's technical account has in your system, on what stays in the log, and on whether a write needs a person to confirm it. Settle those three before the first connection.
Do I need MCP to run an AI agent in my company?
Not always. With one data source and a narrow set of questions, a simpler integration is enough. The standard starts paying off with several systems and plans for more, because then you stop building a separate connector for every system and application pair.
How much does it cost to connect a system over MCP?
The standard carries no licence. You pay for the work: access, data mapping, testing and maintenance, plus model usage at EUR 0.005 to 0.07 per query paid to the provider directly. The process workshop costs EUR 3,500 net per week and the build is quoted after the workshop.
Can an agent connected over MCP change data in a system?
It can, if the account it connects with has those rights. That is why our first connection is always read only, and a write into a production system needs a person to confirm it. Access to a tool and permission to act are two separate decisions.