AI becomes more useful when it can work with your organisation’s information and systems. Model Context Protocol provides a standard way to make those connections. The opportunity starts with understanding where they would actually help.
You ask an AI assistant to prepare for a client meeting.
It produces a sensible agenda. Unfortunately, it knows nothing about yesterday’s support complaint, the proposal sitting in your document library or the commitment someone made on the last call.
So you find the documents. Copy the relevant emails. Explain the background. Correct the dates.
By the time the assistant has enough context, you’ve done much of the preparation yourself.
This is one of the problems Model Context Protocol, usually shortened to MCP, helps address.
It gives AI applications a standard way to connect with external information and tools. With the right connections and permissions, an assistant can retrieve relevant records or perform specific actions instead of relying entirely on what someone pastes into a conversation.
For organisations, that opens up useful possibilities. It also introduces some important design decisions.
First, what actually is MCP?
MCP stands for Model Context Protocol. It is a standard for communication between AI applications and connected systems.
People often say they have “installed an MCP”. Usually, they mean they have connected an MCP server.
That server exposes particular capabilities to an AI application. It might let an assistant search documents, retrieve customer records, inspect website content or create a task.
The AI application works out which available capability could help with the user’s request. The connected service performs the operation and returns a result.
The distinction matters: MCP is the connection standard. The server provides the integration. Your business systems remain responsible for their underlying data and operations.
What does that look like in practice?
Imagine asking:
“Prepare a briefing for tomorrow’s meeting with this customer. Include outstanding support issues, recent decisions and anything we promised to deliver.”
With suitable integrations, the assistant could retrieve information from your CRM, support platform and meeting records, then assemble a briefing with references to the original material.
A different request might be:
“Review these customer complaints, identify recurring problems and draft tasks for the product team.”
The assistant could gather the relevant records, suggest themes and prepare tasks for review.
These are illustrative workflows. What an assistant can actually do depends on the connected tools, the quality of their implementation and the permissions granted to them.
Connecting a system does not automatically make every function within it available.
Where could your organisation use it?
The strongest opportunities often sit in the work between systems.
People collect information from several places, interpret it and manually enter the result somewhere else. That work can be necessary, but it is often repetitive and difficult to scale.
Consider a few examples:
| Area | Potential use |
|---|---|
| Customer service | Bring together order details, previous conversations and relevant guidance to help an adviser resolve an enquiry |
| Sales and account management | Prepare meeting briefs, identify outstanding commitments and draft follow-up actions |
| Marketing | Retrieve campaign results, compare them with agreed objectives and prepare a report |
| Content operations | Find outdated pages, identify inconsistent information and prepare proposed corrections |
| Product and delivery | Connect research findings, support issues and delivery tasks to identify recurring problems |
| Internal knowledge | Help employees find an approved answer and the document supporting it |
The value comes from reducing the effort required to complete a useful task.
A report produced more quickly is helpful. A report that also reduces missed commitments or identifies a problem earlier may be considerably more valuable.
How is this different from an API?
An API gives software a defined way to interact with another system. Many MCP servers use existing APIs underneath.
MCP adds a standard way to present capabilities to compatible AI applications. Those capabilities can include tools that perform operations, resources that provide information and reusable prompts that guide particular tasks.
It does not replace your APIs, databases or business logic. It helps an AI application discover and use the functions an integration deliberately makes available.
A useful implementation might expose an operation such as “retrieve the current status of this order”.
That is easier to govern than giving an assistant unrestricted database access and asking it to work out the organisation’s rules.
The quality of those operations matters as much as the connection itself.
Start with a task people already struggle to complete
“Connect AI to our systems” is too broad a brief.
“Reduce the time account managers spend preparing for customer reviews” is a more useful starting point.
It gives the team something concrete to investigate:
- What information do account managers need?
- Where does it live?
- Which sources are authoritative?
- What do they repeatedly copy or check?
- What requires judgement?
- What would a successful result look like?
That research may reveal an opportunity for MCP. It may also reveal that the underlying problem is inconsistent records, unclear ownership or a missing integration between existing systems.
An AI assistant cannot make an unreliable source authoritative simply by reading it.
Reading information and taking action need different controls
Retrieving a record and changing it carry different consequences.
An assistant that summarises support issues needs access to relevant information. An assistant that issues refunds needs permission to affect a customer’s account and your finances.
That difference should shape the design.
A sensible first implementation can focus on retrieving information and preparing proposed actions. Once the team understands its behaviour, specific write operations can be introduced with appropriate validation and review.
For example, an assistant might prepare a customer email without sending it, or draft a content update without publishing it.
More automated workflows can follow where their scope, reliability and consequences justify them.
The boundary should be enforced by the application and connected systems. A sentence telling the model to “be careful” is not an access control.
Permissions still need to mean something
An MCP connection should not become a shortcut around the organisation’s security model.
You need to establish who is making a request, which records they may access and which operations they may perform. Credentials should be appropriately scoped, sensitive actions validated and activity logged.
Connected content also needs to be treated carefully. A document or support message could contain text that tries to redirect the assistant. Retrieved material should be treated as information to assess, rather than authority to change its instructions.
MCP provides a protocol, not a complete security solution. Access controls, trustworthy server implementations and operational safeguards still need to be designed and maintained.
You may not need to build your own server
Some software providers already offer MCP integrations. Others require a connector or a custom implementation around their existing APIs.
An existing integration is worth evaluating before building something new, but availability alone is not enough.
Check what it can access, what it can change, how it handles authentication and whether it respects the permissions your organisation needs. Establish who operates it and what happens when it fails.
A custom server can be useful when your organisation has specialist systems or workflows. The best design usually exposes a small set of clear business operations.
For example, “retrieve approved product information” or “create a draft service request” gives the assistant a well-defined task with a result the organisation can validate.
Measure the outcome, including the checking
A convincing demonstration can hide a surprising amount of manual correction.
If a briefing takes thirty seconds to generate but twenty minutes to verify, the benefit may be smaller than it first appears.
A pilot should measure the whole task:
- Time taken, including review and correction.
- Accuracy and completeness.
- Whether people can trace claims to their sources.
- Failed requests and how they are handled.
- Any extra work created for other teams.
- Whether employees continue using it after the initial trial.
These measures help distinguish an interesting experiment from a dependable service.
The opportunity is a better way to work
MCP makes it easier to connect AI applications with the tools and information an organisation already uses.
What happens after that is a service design and engineering problem.
People still need to understand what the assistant can do, when to trust it, how to correct it and where responsibility sits. Systems need clear boundaries, useful operations and a way to recover when something goes wrong.
At Absurd, we bring service design and software development together to explore those opportunities, understand the work around them and build connections that serve a practical purpose.