Ask 100 folks what Model Context Protocol (MCP) is, and 80% of them will say, “what?” Another 15% will say it’s basically the same thing as an API. Very few folks truly realize its power.

In this article we’ll explain how MCP works, why it matters, and how you can start taking advantage in a low-risk way.

‍

What MCP Is

MCP basically standardizes how LLMs discover and call tools. It allows your systems to safely be exposed to agents like Claude. It’s not that dissimilar from tools like Zapier in that it gives AI a way to pull from (and sometimes write to) your data and apps.

Prior to MCP, enterprises that were interested in integrating LLMs had to duct tape them together with brittle, one-off connectors. Each agent needed custom code to access internal data or applications.

And every system needed its own connector for every agent. That’s an exponential problem: N tools × M chat agents. Tons of complexity.

MCP changes that by using a schema-first model. Tools are registered with clear definitions for inputs, outputs, authentication, etc. The LLM can then discover what’s available, call functions, and handle responses, without an engineer having to write custom code.

This helps solve for the complexity problem. Build an MCP server once, and it can be reused across all MCP-capable clients.

In short, MCP gives you a safe and convenient way to connect LLMs to your internal tools or other third party systems.

‍

Governance & Safety

What do we mean by safe? It’s generally a bad idea to give AIs uncontrolled access to anything. MCP gives you a structured way to govern and manage an LLM’s use of tools. It does this in a few ways:

• Auth patterns: MCP has support for temporary secrets and OAuth flows.
• Scope management: you can give narrow tool exposure to only what’s needed.
• Rate limits & quotas: you can control usage at the function level.
• Audit logs: you can make sure every tool call is recorded for oversight.
• Defense against prompt injection: MCP has support allow or deny lists. It also has schema validation, which can help prevent data leaks or malicious actions.

From an architectural standpoint, the flow ends up looking like this:

The LLM looks at the MCP registry, discovers available tools, and calls them as needed. The MCP server creates safe access to the underlying systems. This decouples AI agents from enterprise systems and gives  IT a single integration layer to manage.

‍

How to Adopt MCP

MCP is powerful. But we don’t think most organizations shouldn’t jump straight to full automation. Instead, we advocate for a phased path to risk and builds confidence. For example:

‍

Crawl

Start with read-only access. Let chat agents pull project lists, annotations, or record details. This lets you demonstrate the value without giving them the ability to write to your files. Use cases might include things like:

• Pulling active projects, deadlines, or status updates from project management tools.
• Grabbing SOPs, or documentation from your knowledge management platforms, code repositories, etc.
• Pulling recent activity on a client or deal from your CRM.
• Retrieving the last 5 support tickets for a customer.
• Fetching the latest sales by region or NPS scores from analytics platforms.
• Looking up relevant regulatory clauses or internal policies from compliance documentation.
  ‍

Walk:

Expand to carefully-scoped writes. Create a note, add a comment, or open a ticket. Single-step, non-critical actions that have strict rules in place so they don’t go off the rails. Examples:

• Opening a Jira/GitHub issue or ServiceNow incident.
• Appending to a CRM contact or project record.
• Spinning up a Trello or Asana task tagged to a team.
• Inserting a calendar placeholder.
• Highlighting or adding comments in Google Docs or Confluence.
• Triggering a simple workflow approval (an expense pre-check, for example).
  ‍

Run:

Now you can start to chain multiple tools together, design more complicated workflows, or  trigger browser actions. Things like:

• When a support ticket closes, logging a follow-up in CRM and Slack.
• Creating accounts, assigning training tasks, and sending welcome notes.
• Pulling monitoring alerts, logging an incident, notifying on-call team members.
• Gathering RFP requirements from a SharePoint doc, creating Jira epics, and notifying the account team.
• Aggregating competitor mentions from multiple data sources into a single report.
  ‍

The Future of MCP

In the coming years we expect to see MCP get progressively more traction. It’s likely you’ll start seeing agents that highlight, annotate, or trigger workflows directly in your SaaS apps. Multi-tool orchestrations spanning CRM, project management, and data lakes. And LLMs synthesizing across MCP-exposed data, with verifiable sources and audit trails.

It’s not unreasonable to imagine a world where MCP become the de facto enterprise integration layer for LLMs.