This week, we launched LI.FI's MCP server, and it got me thinking: every team in crypto is launching an MCP right now. So I went back to basics. Here's a simple breakdown of what an MCP actually is, why everyone is building one, and what LI.FI's means for agentic commerce.

What is an MCP?

MCP (Model Context Protocol) is an open-source standard for connecting AI applications to external systems.

Think of MCP like USB-C, a standardized way to enable connectivity between different devices running different software. AI applications like Claude are able to leverage MCP to connect with external data sources, workflows, and tools. This provides the AI application with the context or data it may require to look up and execute certain tasks.

Before MCP, connecting an AI agent to an external service meant writing a custom integration every time. This means access to AI agents had to be limited to one application interface that could be missing out on huge datasets or context due to the incompatibility of the AI application and the tools it requires to perform certain requests.

The World Without MCP

Imagine asking a person who has read and memorized every cookbook to cook for you. They’ll have extensive knowledge of every recipe required to prepare every meal. The issue is that this person has never set foot into a kitchen, so they lack the necessary practical context to fulfil any meal requests for you, even if they have all the information to prepare any recipe. This is exactly the issue AI agents faced before MCP:

• Agents could not manage authenticated sessions with external services

• Agents had no way to sign or submit transactions

• Agents had no mechanism to receive live data feeds (current prices, liquidity, gas)

• Agents couldn’t take actions that persisted beyond conversation windows

MCP solved for this by introducing three key architectural components:

• MCP Host: The AI application that coordinates and manages one or multiple MCP clients.

• MCP Client: A component that maintains a connection to an MCP server and obtains context from an MCP server for the MCP host to use.

• MCP Server: A program that provides context to MCP clients.

Depending on where you sit in the ecosystem, MCP can have a range of benefits.

Developers can leverage MCP to reduce development time and complexity when building or integrating with an AI application or agent. AI applications or agents utilize MCP for access to context to fulfil user requests. End-users get to interact with more capable AI applications or agents which can access their data and act on their behalf.

Because MCP is a standardized interface with two main parts: the host and the server, the latter needs to be built in order to allow AI applications to utilize the server for context. LI.FI building an MCP server is like a smartphone company manufacturing a USB-C compatible device. The standard enables interoperability — but we still needed to build the appliance.

Why Developers Are Building with MCP

In the context of blockchains, developers are navigating a fragmented landscape. Hundreds of chains, thousands of tokens, dozens of bridges: each with its own liquidity pools, fee structures, and execution requirements. For a human navigating DeFi, this is already complex. For an autonomous agent that needs deterministic outcomes, blockchain fragmentation is a barrier to autonomous fulfilment. MCP makes integrating AI functionality to DeFi workflows easier by:

1. Writing once, working anywhere. An MCP server works with any MCP-compatible host. Developers aren't rebuilding integrations for every new model or framework they want to support.

2. Agents gain real-world capability. Agents are powerful reasoners but are blind to live state. Agents can't check a balance, execute a swap, or query a protocol in realtime without a tool layer. MCP is how agents get hands, bridging between language and action.

3. Automated composability by default. Agents can chain multiple MCP servers together. An agent could query a data source via one server, reason over the result, then execute an action via another — all within a single agentic flow. This is the foundation of multi-step, autonomous workflows.

4. Ecosystem momentum. MCP has seen rapid adoption across developer tooling, AI frameworks, and infrastructure providers. Building MCP-compatible today means plugging into a growing ecosystem of agents and hosts rather than maintaining isolated integrations.

With MCP, agents make opportunities accessible to end users, but they still need an orchestration layer to navigate cross-chain complexity. To put this thesis to the test, we also launched an agentic trading competition where 5 AI agents are facing off to autonomously trade their portfolios up, starting with $1,000 each all via LI.FI’s MCP server. 

Introducing LI.FI’s MCP Server

MCP connectivity alone doesn't solve the complexity underneath. An agent using a generic MCP connection to a blockchain RPC can technically submit a transaction, but it can't automatically find the best route from USDC on Arbitrum to ETH on Base. It can't compare bridge options, account for slippage, estimate gas across chains, or recover gracefully if a transaction partially completes. Each of those capabilities requires its own integration and error handling.

LI.FI's MCP server abstracts all of this away. Rather than exposing a single RPC endpoint, it wraps LI.FI's entire cross-chain infrastructure into structured tools so agents don't manage complexity, they just call functions. Building directly against fragmented bridge and DEX APIs is months of integration work. LI.FI's MCP server makes it the same as a five-minute config paste. 

Practically, this means developers can use any MCP-compatible agent to go from intent to execution in a single agentic flow. Get a live quote, compare routes across bridges and DEXs, execute a swap, check transaction status — all through standardised tool calls, across any chain LI.FI supports.

LI.FI’s MCP server exposes 15+ tools across six categories: token and chain information, quote and swap execution, routing and discovery, gas estimation, and balance and allowance queries. It's hosted, meaning zero-installation. Developers just paste the config JSON into any MCP client and are able to call LI.FI tools directly. It's compatible with Claude, Cursor, Windsurf, and VS Code Copilot today, with code samples available for TypeScript, Python, and the Vercel AI SDK.

What's left for the developer is the workflow. LI.FI handles everything underneath.

Beyond the MCP Server: A Full Agentic Stack

An MCP server handles connectivity. But for agents to operate reliably at scale, connectivity is only one part of the problem. LI.FI's approach to agentic infrastructure extends across two layers: the MCP server and agent skills distributed across major ecosystems.

Not every developer is building inside an MCP-compatible host. Agent frameworks have their own ecosystems, their own discovery mechanisms, their own ways of extending agent capability. LI.FI's orchestration layer is utilized as native skills across major agentic frameworks available as the lifi-crosschain skill on ClawdHub, a standardised skill on skills.sh, and the official li-fi-api skill on Playbooks.

The practical upshot: a developer building on any of these frameworks can add cross-chain execution to their agent without touching LI.FI's API directly. The capability is already packaged and discoverable within whatever starting environment they're already working in.

The Future of Agentic Commerce 

Blockchains are open, programmable financial systems. AI agents are autonomous decision-makers. The missing piece has always been the orchestration layer bridging the gap between users and opportunities – without human or technical intermediaries getting in the way.

We’re moving away from a past where agents could only talk about executing a swap, to one where agents can execute one in a single prompt autonomously. LI.FI's MCP server and agent skills are the infrastructure stack that makes this possible. The same orchestration layer already powering 1,000+ DeFi applications, now exposed through interfaces built for autonomous systems.

Agents are becoming economic actors. LI.FI is the infrastructure they run on.