Insurtech

The API Is the Product Now: Why Distribution Buys Integration Speed

A small commercial MGA integrates a new distribution partner in three weeks. Fortune 100 carriers have been working on the same problem for two years. Here is why the gap exists, what a working insurance API actually has to do, and why the bar is about to rise again.

Coterie, a small commercial MGA, says it now completes a full distribution partner integration in three weeks. In August 2026 its chief revenue officer, Mark Seich, told Insurance Business that people joining from Fortune 100 carriers describe the same problem back home differently: their organisations “tried to solve that for two years and they’re still so far behind”.

Three weeks against two years is not a rounding error. It is the difference between winning a distribution partner and never being considered for one.

The interesting part of Seich’s argument is what he says the gap is not. It is not money, and it is not engineering headcount, both of which the large carriers have in far greater quantity. It is flexibility. Large carriers tend to offer one standardised integration and expect every partner to conform to it. His test for a carrier is blunt: “Is it an off-the-shelf solution? How fast can they accept what you need?”

What distribution partners are actually buying

For most of the industry’s history, a distribution partner picked a carrier on appetite, price, capacity and service. The integration was an IT detail that got sorted out afterwards.

That order has reversed. When a broker platform, an embedded partner or a comparison site evaluates who to work with, the integration is now part of the product being bought, and often the deciding part. A carrier with slightly worse pricing and a two-week integration will beat a carrier with better pricing and a nine-month one, because the second carrier costs the partner an entire engineering roadmap.

The evidence that this is working shows up in Coterie’s own numbers. Over 650 channel partners, with the majority of business arriving through API connections rather than a portal. More than $200m of direct written premium in 2025, a 66% year-over-year rise in in-force premium, and over 100,000 policies in force. That growth is not the result of a pricing advantage. It is the result of being easy to connect to.

And the prize is large. Gallagher Re puts total MGA premium above $125bn, roughly 12.5% of US property and casualty premium, growing about 10% in 2025 with a similar forecast for 2026. A meaningful share of that is premium that used to sit with carriers and moved because someone else was easier to plug into.

Why the incumbents cannot simply catch up

The two-year figure is not incompetence. It is arithmetic.

  • There is no budget left. PwC research puts insurers’ spend on merely maintaining existing systems at around 70% of the annual IT budget. What remains has to cover regulatory work, security and every other initiative before it reaches partner integration.
  • The friction now costs retention, not just new business. J.D. Power found only 55% of small commercial customers said they “definitely will” renew in 2025, down six points. Awkward servicing is no longer a tolerable cost of doing business.
  • The automation gap is measurable. McKinsey estimates 95% of personal lines policies already move through straight-through processing, while small commercial is not expected to reach that point until around 2030. That five-year gap is precisely the ground tech-enabled MGAs are taking.

There is also a structural point hiding inside Seich’s comment about off-the-shelf solutions. A carrier whose products live as code in a core system can only expose what that system was built to expose. Every partner-specific requirement becomes a change request against a release calendar. A platform where products, rules and rating are configuration can shape an integration to the partner instead of the other way round. That is the difference between three weeks and two years, and it is an architecture decision made years earlier.

What counts as a working API

Most carriers believe they have an API. Fewer have one that a distribution partner would call usable. The bar that partners now apply looks roughly like this:

  • The full policy lifecycle, not just quoting. Quote, bind, issue, endorse, renew, cancel and claims. A quote-only API leaves the partner rekeying everything the moment a sale actually happens, which is the exact work the integration was meant to remove.
  • Self-serve credentials. A developer should be able to get sandbox keys and start building without a sales call, with a certification checklist gating access to production.
  • Modern authentication. OAuth 2.0 with scoped tokens rather than long-lived shared API keys, so permissions can be narrowed per partner and revoked without breaking everyone.
  • A sandbox and real documentation. This is what turns an integration from a six-month project into a three-week sprint. It is also the cheapest item on the list and the one most often skipped.
  • Webhooks, not polling. Partners need to know when a referral clears underwriting or a policy is issued, without hammering an endpoint on a timer.

None of this is exotic. It is ordinary modern software practice, which is rather the point: the standard is being set outside insurance, by every other API a partner’s developers use.

It is not a size problem

The obvious objection is that large carriers are large, and large things move slowly. Chubb Studio is the counter-example. Launched in 2020 as a distribution platform for embedded partners, it now serves more than 150 partners across e-commerce, banking, retail and mobility through APIs and SDKs. It has since gone multi-carrier, so partners can embed third-party products alongside Chubb’s, and picked up an AI optimisation engine in November 2025.

So the capability is achievable at carrier scale. What Chubb did was treat distribution technology as a product with its own roadmap and its own partners, rather than as an integration backlog owned by whoever had capacity.

The plumbing standardised while nobody was watching

One reason this is more tractable than it was five years ago is that the data layer moved. ACORD, whose AL3 flat files and EDI messages defined insurance data exchange for decades, now publishes XML and JSON standards with granular, transaction-centric definitions aimed at APIs and microservices, plus conversion tooling that maps between AL3, XML, JSON and EDIFACT.

The practical consequence is that “we have to support the legacy format” is no longer an argument against building a modern API. Both can be true at once, and the mapping is a solved problem.

Your next integrator is not a person

Here is the part that changes the timeline. Everything above assumes a human developer at a partner company reading your documentation. That assumption is expiring.

On 5 May 2026, Verisk put two Model Context Protocol connectors inside Anthropic’s Claude, covering Underwriting Intelligence (ISO Indications) and XactRestore. Underwriters and claims staff can now ask about loss trends, filing signals and restoration estimates in plain language, without opening a portal at all. The integration target was not a partner’s engineering team. It was a model.

The same shift is happening in the payment rails that any purchase depends on. Google published the Universal Commerce Protocol in January 2026 to let agents work against product catalogues directly. In March 2026 Visa joined the Machine Payments Protocol from Stripe and Tempo, and Mastercard confirmed Europe’s first end-to-end payment executed by an AI agent.

Predictions about when agents will be buying insurance at volume are worth treating with caution; the direction is much better evidenced than any particular date. But the requirement is already clear, and it is strictly harder than the human version: API-first architecture, structured machine-readable data, documentation a model can parse, and credentials that identify and constrain an agent rather than a person. A carrier that has not solved the human integration problem has no route to this one. It is the same plumbing, held to a higher standard.

It also cuts the other way. If agents are going to transact against your systems, the question of who is liable when one gets it wrong stops being hypothetical, which is the subject of the new AI agent insurance products now reaching the market.

What this means if you are building

Openkoda is built around this problem rather than around it. A few specifics.

  • The same product, three ways out. Anything you configure is available as a branded form, an API and an embedded partner checkout, without rebuilding it per channel. That is what makes embedded distribution a configuration exercise instead of a project.
  • Products as configuration, not code. When a partner needs a field you do not collect or a variant you do not sell, the Product Builder and rating engine let a business user make the change and ship it, rather than filing it against a release. This is the mechanism behind a short integration timeline.
  • Full lifecycle, not quote-only. Endorsements, renewals, cancellations and claims are part of policy administration and are exposed the same way quoting is.
  • Agent access with real controls. The MCP server lets an AI assistant work against your live book over the same permissions model your people use, with actions confirm-gated and every call written to the audit trail. Agent readiness and governance are the same feature, which is the only way it can safely work.

If you are an MGA or coverholder, the integration timeline is your commercial argument, so it is worth measuring. If you are a carrier carrying a legacy core, the realistic move is usually not a replacement programme but putting a modern layer in front of what you have and moving products onto it one at a time.

Closing thoughts

The industry spent two decades treating integration as an implementation detail that came after the commercial conversation. Distribution has now reversed that order, and it is showing up in premium: a three-week integration is a growth strategy, and a two-year one is an exit from the market you did not choose.

The uncomfortable part is that the bar is rising again before most carriers have cleared the first one. The next partner reading your documentation may not be a person, and it will not call your account manager for a workaround. It will simply go somewhere it can transact.

If you want to see what a three-week integration looks like from the inside, book a demo and bring a partner spec you are currently stuck on. Openkoda is a configurable platform on published flat pricing, so the answer to “can you support this” is usually a configuration change rather than a quote.

See Openkoda in your context

Book a live, personalized demo with our product team - tell us your use case and see the platform work with your data. No commitment.