Insurance workflows are getting redefined — not by new APIs, but by how we describe and interact with the ones we already have.
Over the past few weeks, we’ve had insurance agents and brokers reaching out with questions about MCPs (Model Context Protocols). Some are seeing chatter in Facebook groups, others are curious how it connects to what we’re building with quoting and servicing workflows. A few went so far as to ask: "Why can't carriers just give us APIs and let us MCP our way into getting quotes and servicing tasks?"
It’s a good question. And the answer is a lot more exciting than most realize.
In this post, we’ll break down what MCPs are, what they’re not, why they matter, and what they could unlock for the insurance industry — not just in quoting, but across the full lifecycle of servicing.
What Are MCPs (Model Context Protocols)?
MCPs are an open protocol for describing the context around APIs, tools, and actions in a way that a Large Language Model (LLM) can understand. Think of it as an API manifest — but not just for code. It’s designed for LLMs to ingest and reason about:
- What a tool does
- What inputs it needs
- What outputs it returns (and how the output is formatted)
- What constraints or validations apply
- What kind of user intent should trigger it
Rather than coding a fixed integration between your app and a carrier’s API, you expose a tool definition (via MCP) and let an AI agent figure out how and when to use it based on user queries, workflows, or UI actions.
It’s the difference between hardcoding a Salesforce integration vs. plugging it into Zapier and letting users orchestrate things with natural language.
Why MCPs Matter for Insurance
Insurance is a notoriously fragmented industry. Carriers have wildly different systems. APIs (when available) are bespoke, undocumented, or fragile. Although players like ACORD have established standards in the nomenclature of the industry, insurtech providers largely operate in silos. As a result, insurance brokers rely on manual entry into portals. Startups spend months integrating one carrier at a time, one AMS at a time, and one rater at a time.
MCPs change that. Provided the underlying APIs are exposed and accessible (a big IF), MCPs can unlock:
- Faster Integrations – Instead of building a full-fledged API client, startups can describe the quoting or servicing action once and let the model handle the glue logic.
- Dynamic Workflows – Insurance brokers can query different carriers and AMS through natural language or UI commands, and the underlying MCPs guide the model to the correct API call.
- Lower Maintenance Costs – When an API changes, you just update the MCP description — not your entire integration stack. Fun fact: established InsurTech players have a third of their developers maintaining integrations vs. innovating.
But make no mistake, MCPs don’t open locked doors; they help you navigate the ones already API-able. And that's where Agentic Browsing will come to the rescue (soon with Gaya :-D)
Will MCPs Replace APIs?
No — and they’re not supposed to.
MCPs don’t replace APIs; they contextualize them.
Carriers and AMS providers will still have to expose their APIs. MCPs act as wrappers or interface descriptions that make those APIs easier for LLM-based systems to reason about. It’s like giving your API a voice and a guidebook for how it should be used.
So, if you’re a carrier, a rater or an AMS provider, MCPs help you scale distribution and integration without exposing raw credentials or writing custom SDKs for every partner. And if you’re a startup, you get a plug-and-play-like development surface.
But Wait... Aren’t MCPs Probabilistic?
Yes, LLM-based workflows are inherently probabilistic. An MCP-compliant model is deciding how to route and execute tasks, and that introduces non-determinism.
But that’s not a deal-breaker. Here’s why:
- High-confidence paths can be validated and piped automatically.
- Low-confidence paths can trigger fallback logic, user confirmation, or re-routing.
- Over time, as data accumulates and use cases stabilize, the outputs become increasingly deterministic.
The LLM doesn’t have free rein — it’s operating inside a well-structured environment with guardrails, schemas, and validations. It’s not the wild west. It’s more like an AI-powered middleware layer.
Who Benefits Most?
• Insurtech Startups
They can move faster, test more carriers and AMS platforms, iterate quicker, and avoid being bogged down in API hell.
• Carriers & AMS Providers
They get safer, more manageable distribution and integration channels. No need to maintain bespoke API partnerships with every quoting or servicing platform.
• Agencies
Eventually, agencies won’t even know they’re using MCP-backed workflows. They’ll just experience faster quoting, streamlined servicing, fewer errors, and more intelligent systems.
The "Unofficial MCP" Forcing Function
Some people argue that insurance giants will take years to adopt this. And they might — officially.
But what if you don’t wait?
We’ve seen it happen in other industries: when there’s enough demand and usage, developers create unofficial MCPs. They maintain them. They contribute updates. They share them in Slack groups and GitHub repos.
Once these unofficial MCPs reach critical mass, the original API provider is almost forced to acknowledge and support them — because the ecosystem has already moved.
This isn’t a theory. It’s how standards get created: from the bottom up. Swagger didn’t become OpenAPI overnight — developers made it the de facto way to describe REST APIs.
The same will happen here.
What Comes Next
Sure, MCPs aren’t fully baked yet. But they’re coming — fast. And once adoption hits a tipping point, we’ll see:
- Carrier and AMS APIs being MCP-wrapped
- AI tools like Gaya that can quote, endorse, cancel, and fetch data out of the box
- Hybrid flows where models pipe to deterministic services on the backend
At that point, it won’t be about if they support MCPs — it’ll be about how well they do.
We’re watching this closely — and building towards that world. MCPs and Agentic Browsing for whenever APIs are not accessible are a natural evolution for broker’s enablement.
If you're a broker, a carrier, an AMS platform, or an insurtech builder and want to talk more about MCP compatibility, feel free to reach out.