How MCP is Enabling Effective AI Agents

Is your AI strategy ready for what's next?

We're moving beyond simple chat interfaces into an era where AI agents interpret intent, make decisions, and execute tasks across different systems. But how do they access external tools and services seamlessly? That's where the Model Context Protocol (MCP) comes in.

In this episode of the Inspiring Tech Leaders podcast, I explore how the Model Context Protocol (MCP) is revolutionising how AI agents interact with tools, and how innovations from Anthropic and Cloudflare are solving the critical challenge of context bloat.

Learn how to build more efficient, powerful, and scalable AI systems. This is a must-listen for any tech leader shaping their organisation's AI future.

Available on: Apple Podcasts | Spotify | YouTube | All major podcast platforms

Start building your thought leadership portfolio today with INSPO.  Wherever you are in your professional journey, whether you're just starting out or well established, you have knowledge, experience, and perspectives worth sharing. Showcase your thinking, connect through ideas, and make your voice part of something bigger at INSPO - https://www.inspo.expert/

Transcript

Welcome to the Inspiring Tech Leaders podcast, with me Dave Roberts. Today I’m looking at a technical shift that is redefining what AI agents can actually do in the real world. The topic is the Model Context Protocol, more commonly referred to as MCP, and how recent developments are making AI agents more powerful, more efficient and far more practical for enterprise use.

If you have been following the rapid evolution of artificial intelligence, you will have noticed that the conversation has moved beyond simple chat interfaces. We are now firmly in the era of AI agents. These are systems that do not just respond to prompts but can take action, orchestrate workflows and interact with external systems. However, for all the excitement around agents, there is a critical layer underneath that makes them viable. That layer is MCP.

To understand why MCP matters, we first need to clarify what an AI agent actually is. An AI agent is a system powered by a large language model that can interpret intent, make decisions and execute tasks across different systems. For example, an agent might read customer enquiries, extract relevant data from a CRM platform, generate a proposal and send it for approval. It might analyse engineering tickets, prioritise them and trigger deployment workflows. The key point is that an agent is responsible for reasoning and orchestration.

However, an agent cannot simply reach into every system on the internet by itself. It needs structured access to external tools and services. Historically, that has meant building custom integrations or exposing APIs in ways that are difficult for language models to interpret consistently. This is precisely where MCP comes in.

The Model Context Protocol is not an agent. It does not make decisions and it does not independently run workflows. Instead, it provides a standardised way for AI models to discover and interact with tools. You can think of MCP as a universal connector layer designed specifically for AI systems. Just as REST standardised how web services communicate, MCP standardises how models access external capabilities.

In practical terms, an MCP server exposes tools in a structured format that a model can understand. These tools might represent actions such as retrieving data from a database, creating a support ticket, deploying code or querying an analytics platform. The AI agent reviews the available tools, selects the appropriate one and invokes it based on user intent. MCP ensures that the interaction between the model and the tool is predictable, secure and well defined.

This separation of responsibilities is important. The agent handles reasoning and orchestration. MCP handles structured access to external systems. Together they form a modular architecture that allows organisations to scale AI functionality without building bespoke integrations for every possible use case.

However, as elegant as this architecture sounds, early implementations exposed a significant technical challenge. That challenge was context size and token consumption.

Large language models operate within a fixed context window. Every instruction, tool definition and intermediate result must fit inside that window. When organisations began building MCP servers connected to hundreds or even thousands of tools, they discovered that each tool definition had to be included in the model’s context before the agent could make an informed decision.

This created what many engineers began to call context bloat. Instead of focusing on the user’s request, the model was forced to load extensive tool descriptions into memory. In some cases, tens of thousands of tokens were consumed simply listing the available capabilities. That is before any actual reasoning even began.

The inefficiency compounded when agents needed to chain multiple tool calls together. Suppose an agent retrieves data, processes it, filters it and then writes it somewhere else. Each intermediate result traditionally had to be passed back into the model’s context so it could determine the next step. This significantly increased latency and cost, and reduced scalability.

In a production environment where thousands of tasks might be running concurrently, these inefficiencies become commercially meaningful. Higher token usage translates directly into higher compute costs. Longer context windows increase processing time. And greater complexity introduces more potential points of failure.

This is the problem that Anthropic’s engineering team sought to address with an approach known as code execution with MCP.

Instead of forcing the model to directly call tools in a step-by-step conversational loop, Anthropic have approached this in a new way. The model writes code that orchestrates the tools, and that code executes in a secure environment outside the model’s context window.

This may sound subtle, but it represents an important architectural change. Rather than loading every possible tool definition into memory and repeatedly passing intermediate outputs back into the model, the agent generates a concise program that performs the required operations autonomously.

The execution environment handles loops, conditional logic, filtering and data transformation. Only the final result is returned to the model. The heavy lifting happens outside the model’s cognitive workspace.

The benefits are significant. Token usage drops dramatically because the model no longer needs to ingest extensive tool metadata. Latency improves because fewer round trips are required between model and tool. Security is enhanced because sensitive intermediate data can remain within the execution environment rather than being repeatedly exposed to the language model.

In documented examples, tasks that previously consumed well over one hundred thousand tokens were reduced to only a few thousand. That is not a marginal optimisation. It is an order of magnitude improvement.

From a leadership perspective, this matters because it shifts agents from being experimental curiosities to commercially viable infrastructure components. When cost, speed and security improve simultaneously, adoption accelerates.

Cloudflare then took these ideas a step further with what they call Code Mode for MCP. Their approach demonstrates how the principles of code execution can be applied at scale within a large API ecosystem.

Traditionally, if Cloudflare exposed its entire API surface area as separate MCP tools, the number of tool definitions would be enormous. Each endpoint might represent a distinct action. Loading all of them into the model’s context would be impractical.

Instead, Cloudflare introduced a simplified interface built around two core primitives. One allows the model to search the API specification. The other allows it to execute code against that specification. Rather than selecting from thousands of predefined tools, the agent dynamically explores the API and writes JavaScript to interact with it.

The code runs within a secure, isolated sandbox. It can handle pagination, chaining of requests, filtering of results and complex workflows without repeatedly expanding the model’s context. Only essential outputs are returned.

The efficiency gains are dramatic. Context requirements shrink to a fraction of their previous size. In some reported scenarios, reductions approached 99%. That makes large scale API orchestration not only possible but practical.

What makes this development particularly interesting is that it transforms APIs into programmable environments from the model’s perspective. Instead of statically enumerating every capability, the agent can dynamically reason about the API structure and generate tailored code for specific tasks.

This pattern has broader implications for enterprise architecture. It suggests that future AI systems will increasingly rely on execution layers that sit between the model and the outside world. The model becomes a reasoning engine. The execution environment becomes an action engine.

For technology leaders, this separation introduces new governance considerations. Execution environments must be secure, auditable and sandboxed appropriately. Code generation must be monitored and validated. Observability becomes critical. Yet the advantages in flexibility and performance are substantial.

It also reinforces an important strategic insight. AI maturity is no longer solely about model capability. It is about systems design. The organisations that succeed will be those that invest not only in powerful models but in efficient orchestration layers, secure execution frameworks and scalable integration protocols.

So what should you take away from all of this?

First, AI agents and MCP serve distinct but complementary roles. Agents reason and decide. MCP structures and standardises tool access. Confusing the two leads to architectural misunderstandings.

Secondly, naive implementations of tool calling can become inefficient at scale. Token bloat is not merely a theoretical concern. It directly affects cost, latency and performance.

Thirdly, code execution with MCP represents a pivotal evolution. By shifting orchestration logic into a secure execution environment, organisations can dramatically reduce overhead while increasing capability.

And finally, the examples shared today demonstrate that this is not just theory. It is already being operationalised in production environments.

We are moving towards a world in which AI agents are not simply answering questions but running workflows, managing infrastructure and coordinating complex systems. For that vision to become reality, the underlying plumbing must be robust and efficient. MCP, combined with intelligent execution layers, provides that foundation.

As Technology Leaders, the goal is not simply to understand emerging technology but to interpret its strategic significance. If you are shaping AI strategy within your organisation, pay attention to how your agents access tools, how context is managed and where execution actually occurs. These design decisions will determine whether your AI initiatives scale gracefully or struggle under their own weight.

Well, that is all for today. Thanks for tuning in to the Inspiring Tech Leaders podcast. If you enjoyed this episode, don’t forget to subscribe, leave a review, and share it with your network.  You can find more insights, show notes, and resources at www.inspiringtechleaders.com

Head over to the social media channels, you can find Inspiring Tech Leaders on X, Instagram, INSPO and TikTok.  And let me know your thoughts on MCP.

Thanks for listening, and until next time, stay curious, stay connected, and keep pushing the boundaries of what is possible in tech.