Most organisations already use automation and data-driven tools to support everyday decisions. The challenge for data and AI leaders is turning these capabilities into reliable outcomes inside core business processes. Many of these initiatives stall because they never get connected to the systems people actually use to do their work.

Why does this keep happening, even in organisations with strong data and AI teams?

The latest Data Masterclass community call focused on this challenge. The session brought together Alexander Borek and Aleksejs Plotnikovs (Data Masterclass), Francesco Mucio (Architecture Coach), Jo and Aydin Geeringh (Collate), and enterprise leaders from Scout24 and JustWatch to share practical experiences from real implementations.

One theme was consistent across all examples. Connection is the real limiting factor. Systems only create value when they can access the same tools, data, and operational platforms that employees rely on every day. This is where Model Context Protocol (MCP) comes into play.

As Alexander put it, “This is not science fiction. This is happening right now.”

Subscribe to our newsletter to stay updated on upcoming events and community calls.

The Core Problem: AI Without Tools Can’t Deliver

Enterprises are not short on systems. Over time, they have accumulated:

• CRM platforms
• ERP systems
• Ticketing tools
• Data warehouses and BI layers
• Documentation and internal knowledge tools

Together, these systems form the backbone of how work actually gets done.

Now imagine trying to operate in this environment without access to any of them.

The challenge for agents is that without access to these systems, they cannot deliver meaningful outcomes. Just as a human employee cannot onboard a colleague without access to HR systems, agents are limited by what they can reach.

Most organisations try to solve this through custom integrations. Each new agent requires new connections to each relevant system. As the number of tools grows, the number of required integrations grows even faster.

Alexander summarised the problem clearly: “If you have 100 tools, you need hundreds of integrations.”

Without a common standard, this approach quickly becomes expensive, fragile, and difficult to scale.

MCP = The API Layer of the Agentic Era

To understand why MCP matters, we must look at how software has evolved. In the past, APIs became the standard way for applications to communicate with each other. They allowed systems to expose capabilities in a structured, predictable way and enabled the building of complex software landscapes without hard-coding every connection.

AI agents face a similar challenge today. They need a consistent way to discover, understand, and use enterprise tools without custom logic for every system. MCP fills this gap by acting as a thin, standardised layer between agents and existing infrastructure.

MCP wraps enterprise APIs and services in a format that AI agents can interpret and use safely. Rather than teaching each agent how every system works, organisations expose capabilities once and make them reusable across agents.

As Alexander described this, “MCP allows you to create a wrapper around your API that is AI readable.”

This approach is why MCP is quickly gaining traction. It reduces integration complexity, enables reuse, and provides a foundation that scales as agent adoption grows.

Why MCP Matters (Accuracy and Action Beyond LLMs)

Large language models are powerful, but they come with structural limitations that cannot be solved by scale alone. They are probabilistic by design, which means they generate likely answers rather than verified ones. They are also trained on historical data, which creates a natural knowledge cutoff.

These limits quickly become a problem in enterprise environments, because decisions depend on up-to-date data and real system state. No matter how advanced the model, it will never natively know what is happening right now inside an organisation’s databases, applications, or workflows.

MCP addresses this gap by connecting models to authoritative systems of record. Instead of guessing, agents can retrieve verified information directly from enterprise tools. More importantly, MCP goes beyond information access. It enables agents to execute actions in those systems, turning AI from a conversational layer into an operational one.

As Francesco put it, “MCP can… not only collect information but also act on the external world.”

This shift from response to action is what makes MCP essential for real enterprise impact.

MCP in Action: From Question to Data Quality Rule

The Collate demo showed what changes when an agent is properly connected to enterprise data systems. Instead of switching between tools, users worked through a single conversational interface in Claude.

The process followed a clear flow:

• Retrieve the official business definition from the glossary
• Identify the relevant Snowflake tables
• Trace downstream dashboards and reports
• Propose and execute a data quality rule

The interaction began with a simple business question about product categories. Claude used MCP to query Collate’s business glossary and retrieve the governed definition. It then identified the relevant Snowflake tables, without the user needing to know schemas or table names.

Next, the agent traced data lineage and surfaced which dashboards and reports depended on that data, highlighting where issues would have the greatest business impact.

Finally, Claude proposed a data quality rule for the product category field and executed it directly in the data platform. A task that would normally involve several teams was completed in minutes.

As Jo from Collate added, “It’s giving that one thread that’s standardized, governed.”

The demo showed how MCP supports governed execution, not just answers.

Scout24: MCP Makes Self-Service Real

Scout24 shared a practical example of how MCP changes everyday access to data in a large organisation. Before MCP, answering business questions often meant going through central data teams. Requests came in, analysts searched schemas and tables, and answers were delivered later. Even when the data existed, the process slowed teams down and limited real self-service.

With MCP in place, Scout24 moved to conversational access. Users could ask questions directly in chat, and an AI agent retrieved answers from the data platform in real time. Because the agent was connected to governed systems, responses were based on current, trusted data rather than assumptions or outdated documentation.

The impact was immediate. Instead of waiting days or weeks, users got answers during the conversation itself. This reduced friction and encouraged more exploration, leading to better, faster decisions across teams.

The rollout was also fast. What began as a small internal experiment was turned into a production setup within weeks, without a large transformation programme.

As Kiran from Scout24 summarised, “The time to insights was weeks… now it happens then and there.”

Internal MCPs Are the Real Success Story

While public MCP servers attract attention, the discussion made clear that the biggest impact is happening internally. Organisations are using MCP to connect agents to their own systems and workflows.

JustWatch shared how they built an internal MCP ecosystem by connecting multiple services through a single conversational interface. This allowed agents to assist with tasks like monitoring pipelines, diagnosing issues, and retrieving operational context without switching tools.

The top advantage of internal MCPs is compounding value. Once core services are exposed, new use cases reuse the same connections instead of rebuilding them.

Governance and Guardrails

As MCP enables AI agents to move from answering questions to executing actions, governance becomes critical. Connecting agents to enterprise systems increases power, but it also increases risk if access is not carefully controlled.

The discussion emphasised the principle of least privilege. Agents should only be able to access the tools and actions required for their specific tasks, nothing more. This limits blast radius and helps organisations maintain trust as agent capabilities expand.

Equally important is keeping humans in the loop for high-impact decisions. While agents can automate routine actions, sensitive or irreversible operations should require explicit approval. This ensures accountability and aligns AI behaviour with organisational responsibility.

Finally, observability plays a key role. MCP-based interactions can be logged, monitored, and audited, making agent behaviour transparent and easier to improve over time.

As Francesco added, “Keep a human in the loop… high-stakes actions require manual approval.”

Closing Takeaway: MCP as Enterprise Infrastructure

The discussion showed that progress slows when every new use case requires custom connections. A shared way of connecting tools and systems allows teams to reuse what they’ve already built and focus on improving how work gets done.

This pattern is familiar. APIs followed the same path, moving from something new to basic infrastructure. The same shift is now underway here. As more operational work relies on connected workflows, consistency, reuse, and governance become essential.

As Alexander noted during the session, “MCP servers are probably even more important to know than how to build AI agents.”

If you want to continue the conversation and explore how these foundations translate into everyday productivity at scale, join the next Data Masterclass community call.

Join Our Live Upcoming Community Call: How to provide general AI productivity at an enterprise?