Building an Insurance AI Agent That Can Answer Why

A first notice of loss call collects up to 145 data points and writes them into a System of Record, where they drive a real decision on a real claim. Making that call sound natural is the part that demos well. Making it behave the same way on turn sixty as it did on turn one, and leave a record of why it did what it did, is the part that decides whether a carrier can put it in production.

In practice, “answering why” means being able to reconstruct which facts the agent collected, which rules or decisions advanced the conversation and which action plan produced the final outcome. 

No-code builders and "LLM plus tools" agents don't clear that bar. They handle the happy path well and break at the edges: they drift off task, degrade as context grows, and give you no way to explain a decision after the fact. In insurance, the edges are where the stakes are. 

How Liberate answers the challenge: We assemble an agent from small, individually testable components instead of one large model asked to do everything. The thesis behind it is short. Complexity in an agent system is conserved. You don't eliminate it. You decide where it lives.

Complexity is conserved

You can put the complexity in the prompt. You write a system prompt encoding the flow, the rules, the exceptions, the tone, and the things the agent must never say, and you hope the model untangles all of it on every turn. This works until it doesn't. The tell is easy to spot: the moment a prompt starts accumulating if/else rules and "always do X, never do Y" clauses, that logic wants to be code. Prompt sprawl is a maintainability tax. Every clause widens the test surface, and the interactions between clauses stay invisible until they fail on a live call.

Or you can decompose. Break the agent into discrete components, some LLM calls and some plain code, with real orchestration between them. The complexity is still there. It's just in a form you can read, version, unit test, and reason about.

LLMs are a trap when you require a specific outcome. They're extraordinary at judgment, extraction, and prose, and they're the wrong tool for anything that has to work identically every time. So we use the model for what it's good at and software for the rest. 

What we built

Liberate’s agent has four components: capture, confirmation, orchestration, and response. Each is small, has a narrow job, and can be tested on its own. Config is the assembly that turns those parts into a working agent, a direct extension of the Config, Not Code principle behind our 4-6 week standard go-live.

The LLM works at the borders. It extracts structured data from what a caller actually said, and generates natural language on the way back out. Judgment and prose. The model beats any code we'd write.

Code holds the core. Flow control, readback formatting, and mandated language run on fixed scripts and code-based formatters. Where a passage has to be exact, software plays it verbatim and without interruption, rather than a model guessing at the phrasing.

Flow is a state machine, not a black box. The conversation advances on facts, decisions, and action plans persisted to state, and every change is recorded.

Templates carry the customer's voice. A carrier supplies their own wording, either played verbatim or used as a reference and a hint for how the model phrases its response. Customers get their brand without giving up control of what gets said.

Structurally, this is how the Agent Layer is built. The Orchestration Layer still executes the transaction and writes back to Guidewire, Insuresoft, Duck Creek, Snapsheet, Applied Epic, AMS360 and Vertafore with full audit trails. The Supervisor Layer still governs in real time. 

What we found

1. The line between model and code is a design decision, not a technical limit. 

Nothing forces the recording disclosure to be generated by an LLM. Nothing forces a claim number readback to be phrased by a model. Once you stop treating the agent as one model with a long prompt, each of those moments becomes a choice about which component owns it. A model's best guess isn't dependable enough for language a regulator will read back to you.

2. Specialization is what holds quality on a long call. 

Auto FNOL runs as seven sequential sub-agents collecting up to 145 data points. Home FNOL collects up to 95. Give one model that entire job and its context grows unbounded across a 15-minute conversation, with quality decaying alongside it. Give each component a narrow job and only the context it needs, and the context window moves with the conversation instead of accumulating. Quality holds from the first turn to the last.

3. Persisting state gives you the audit surface for free.

‍Because facts, decisions, and action plans are written to state on every change, the debug and audit surface is a byproduct of the architecture rather than a logging feature bolted on afterward. The parts that can fail are parts you can inspect. Customer trust doesn't come from the demo. It comes from being able to answer why the system did what it did. "Because LLMs are non-deterministic" isn't an answer. It's a confession that the system has no observability, and in insurance it's a liability.

4. Components make the product modular, and modularity is why we ship an insurance operating model instead of a blank canvas.

Agents are assembled from reusable, insurance-specific blocks per line of business. A claims agent uses a verification block we designed and recommend as the default; a customer can adopt it as is or extend it for their own workflows. Underneath sits our canonical domain model, the data model driving the interaction end to end, from what gets collected on the call through to third-party vendor integration. And because each block is independent, we can update individual components as we learn from production and the change stays contained. Improvements ship to one block without rippling through the rest of the product.

5. AI governance has explicit regulatory expectations.

The NAIC Model Bulletin on the Use of AI Systems by Insurers expects a written AI Systems Program and names "the transparency and explainability of outcomes to the impacted consumer" as one of five factors determining how much control a use case needs. It also tells insurers what a regulator will ask for in a market conduct action: model inventories, validation records, documentation of the controls actually applied. That's why "answer why" is the design goal rather than a feature.

6. Mandated language has to be exact.

Many states require all-party consent to record a call. Call-recording requirements vary by jurisdiction, and the required disclosure may depend on where the parties are located and how the call is handled. That variability strengthens the case for deterministic speech control. When a disclosure is required, the correct version should be selected by rule, delivered verbatim and protected from interruption.

The production reality

The borders are still non-deterministic. Extraction can misread what a caller said. That's why confirm exists as its own component and why the Supervisor Layer warm-transfers when confidence drops. We shrink the non-deterministic surface. We don't get it to zero and we don't claim to. The average autonomous completion rate on the hardest use case (FNOL) is still 45% to 55%. Escalation is a feature there, not a failure. But half those calls still need a person, which means half the problem is still headroom. That's where the remaining opportunity lies. 

Why it matters on the call

A policyholder calls at three in the morning because their house just flooded. They need someone to take the details down right the first time, and to tell them what happens next. A misheard address is a delayed inspection. A misstated coverage is a promise the carrier never made. Getting the readback exact isn't compliance theater. It's the difference between a family knowing help is coming and a family calling back tomorrow to start over. On the other end, an adjuster who used to spend the morning on intake paperwork gets the morning back. That's the trade we're building.

As agents take on longer and more consequential work, the systems that survive audit won't be the ones with the cleverest prompts. They'll be the ones where the non-deterministic surface is small, deliberate, and documented, and where every decision has a recorded reason attached. Complexity is conserved either way. The only question is whether you chose where it went.

If you are an engineer who wants to work on this, making agent evaluation rigorous, fast, and grounded in real conversations, we’re hiring.