AI Agents for Insurance

Autonomous AI agents that handle specific insurance workflows end-to-end, FNOL intake, underwriting data gathering, claims status, renewal reminders, fraud signal detection, and subrogation identification.

Built for insurers, MGAs, underwriters, and claims teams who need agents taking actions in insurance workflows, not just answering questions.

  • FNOL intake agents that collect, validate, and route first notice of loss from any channel

  • Underwriting data agents that query CLUE, MVR, credit bureaus, and property databases and return structured output for review

  • Claims status agents that give policyholders real-time updates without advisor involvement

  • Compliance-aware architecture with full audit trails and configurable human-in-the-loop checkpoints

RaftLabs builds autonomous AI agents for insurance workflows, FNOL intake, underwriting data extraction, claims status, policy renewal reminders, fraud signal flagging, and subrogation identification. Unlike rule-based automation, these agents take actions end-to-end across multiple data sources, apply configurable decision logic, and escalate to human reviewers at defined checkpoints. Most insurance AI agent projects deliver in 10-14 weeks at a fixed cost. Architecture follows insurance compliance requirements including data handling controls and full audit trails per carrier and MGA standards.

Recognition

Sound familiar?

  • Your claims team re-keying the same FNOL data from emails, portals, and phone notes into your system of record, every single intake?

  • Underwriting data collection from CLUE, MVR, and third-party sources taking days and pulling attention away from actual risk assessment?

  • Claims advisors fielding status-update calls that a self-serve agent could handle without touching a human?

Companies we've built for

Vodafone
Nike
Microsoft
Cisco
T-Mobile
Aldi
Heineken
GE
Products shipped
100+
Cost delivery
Fixed
Week delivery
10-14
Fintech and insurance platforms
15+

AI agents that act, not just answer

A chatbot tells a policyholder how to file a claim. An AI agent collects the FNOL data, validates it against the policy record, creates the claim in your system, assigns it to the right adjuster by claim type and value, and sends the first status message, all from a single inbound contact.

The difference matters in insurance because half-finished workflows create the cost. When a FNOL lands by email and a handler has to open three systems, re-key the data, and manually route it, that is not a training problem. It is a workflow problem. Agents fix it by owning the workflow from intake to handoff, with defined escalation logic for the exceptions that genuinely need a human.

We build insurance AI agents with a defined scope per workflow, explicit escalation rules, and compliance-aware data handling. Each agent does one insurance workflow well. Integration with your policy administration system and claims platform is scoped during discovery, that is where most projects find their real complexity.

What we build

  1. FNOL intake agent

    When a first notice of loss arrives, by email, web portal submission, SMS, or phone transcript, the agent extracts the structured FNOL data: policy number, claimant details, date and description of loss, loss location, involved parties, and any supporting documents attached. Extraction runs against the raw inbound content using an LLM with structured output validation, mapping to your ACORD-aligned intake schema or your system's native field structure.

    The agent validates the extracted policy number against your policy administration system via API, confirms the policy is in force, and checks whether the reported loss date falls within the coverage period. If validation passes, it creates the claim record in your claims management system with the structured FNOL data pre-populated and attaches the source documents to the claim file. If validation fails, unrecognised policy number, expired policy, or loss date outside the coverage period, the agent flags the exception with the specific reason and routes it to a handler queue for manual review, along with the full inbound content so the handler has everything they need without hunting for it.

    Claim routing uses configurable rules: claim type, estimated loss value, line of business, and any triage criteria your operations team defines. The right adjuster queue or team receives the new claim with a structured summary, not a raw email forwarded from an inbox. The full extraction and routing logic is built as a LangGraph directed workflow with explicit state transitions, so every step is logged and the audit trail shows exactly what the agent extracted, what it validated, and what routing decision it made, per your compliance and audit requirements.

  2. Underwriting data extraction agent

    Underwriting a new submission requires data from sources that don't send it proactively: CLUE property and auto loss history reports, MVR driving records, credit and financial stability data, property characteristics from geocoded databases, and for commercial lines, D&B or similar company data. Retrieving all of it for a single submission takes time that slows your underwriting queue, especially when the volume of new submissions is high.

    The agent accepts a new submission and kicks off parallel data retrieval: CLUE report request via your existing bureau connection or an ACORD-standard API integration, MVR request per driver listed on the submission, credit data pull, and property database query for the risk address. Each retrieval runs asynchronously. Results come back on different timescales, MVRs typically return within seconds to minutes, CLUE within minutes, credit within seconds. The agent collects each result as it arrives and assembles the complete data package.

    When all retrievals are complete (or when a configurable timeout is reached for any source that is slow to respond), the agent produces a structured underwriting data package: CLUE loss summary with dates, perils, and reserve amounts; MVR violations and licence status per driver; property characteristics including construction type, year built, and prior loss indicators; and a normalised credit or financial data summary. It attaches this package to the submission record in your underwriting workbench or policy admin system and notifies the assigned underwriter that the data is ready for review. The underwriter starts their assessment with all third-party data already assembled, not waiting for it, not retrieving it manually, not reconciling data from separate exports.

    The data retrieval workflow is stateful via LangGraph: each bureau integration is a node, partial failures are handled gracefully (if CLUE returns an error the agent logs it and flags it for manual follow-up rather than stalling), and the full retrieval history is available for audit. MRC-aligned structured output means the data package can be consumed by downstream rating or pricing tools without reformatting.

  3. Claims status agent

    Between the FNOL and claim resolution, policyholders want to know what is happening with their claim. This is one of the highest-volume, lowest-value contact types in claims operations, the adjuster knows the status but has to stop what they are doing to communicate it. A claims status agent handles this interaction end-to-end.

    The agent connects to your claims management system via API and retrieves current claim status on demand: current stage in the workflow, last activity recorded, any outstanding document requests, estimated payment timelines where available, and assigned adjuster contact information for escalation. It surfaces this through whatever contact channel the policyholder uses, a web portal widget, SMS, email reply, or voice IVR integration depending on your channel mix.

    For inbound status enquiries (email or message saying "what is the status of my claim?"), the agent extracts the claim reference or policy number from the inbound message, queries the claims system, and sends a structured status response: what stage the claim is at, what happened most recently, what, if anything, is needed from the policyholder, and when the next update is expected. The response uses plain language generated by the LLM from the structured claims data, not a template that reads like an automated message.

    For proactive updates, the agent monitors the claims workflow for defined trigger events, adjuster assignment, document received, inspection scheduled, payment authorised, payment sent, and sends a proactive notification to the policyholder at each trigger without requiring adjuster action. The agent escalates to a human only when the policyholder's inbound message indicates they are dissatisfied with the status or when they explicitly ask to speak to someone, routing those contacts to the right queue with the full conversation history attached.

  4. Policy renewal reminder agent

    Policy renewals that are not actively managed lapse, the policyholder either forgets to renew, doesn't receive a clear renewal prompt, or gets a renewal pack they don't understand and doesn't act on. A renewal reminder agent drives renewal contact across the pre-renewal window without requiring manual outreach scheduling.

    The agent queries your policy administration system for policies approaching renewal within a configurable window (typically 60, 30, and 14 days before expiry). For each policy in the renewal window, it retrieves the current premium, any mid-term changes, renewal terms offered, and the policyholder's preferred contact channel. It generates personalised renewal communications, structured around the specific policy, current coverage, renewal premium, and any changes, using the LLM with a prompt template your marketing and compliance team approves before deployment. Generated content passes through a structured output validation step confirming required regulatory disclosure elements are present before any message is sent.

    Outreach runs across channels in preference order: email, SMS, and portal notification. Response tracking monitors whether the policyholder has opened the renewal pack, clicked through to the renewal portal, or completed the renewal. Non-responders move to the next outreach step at the configured interval. Policyholders who request changes to coverage or raise a question about their renewal terms are flagged to a broker or account manager with the full conversation thread, rather than the agent attempting to handle coverage change requests itself, that decision stays with a human.

    Policies that lapse despite outreach are flagged with the full outreach history: what was sent, when, which channel, and what response (if any) was received. This gives your operations team the audit trail they need for compliance and the context they need for any reinstatement conversation with the policyholder.

  5. Fraud signal flagging agent

    Claims fraud costs UK insurers over £1 billion annually in detected fraud alone, and SIU teams are already stretched reviewing the volume of claims they receive. A fraud signal flagging agent surfaces anomaly signals on new claims so SIU reviewers spend their time on the claims most likely to warrant investigation, not on random sampling.

    The agent runs on each new claim as it is created. It checks a configurable set of fraud indicators against the claim data: policy age relative to first claim (new policy, high-value claim shortly after inception), reported loss timing patterns (claim filed on weekend or late evening, loss occurring just before renewal), claimant history from CLUE (prior claims frequency and types), third-party corroboration gaps (no police report for a reported theft, no repair estimate for a vehicle claim above a set threshold), and for property claims, catastrophe event correlation (loss reported during a declared event but outside the affected geography).

    Each signal check produces a binary flag and a signal description. The agent aggregates the flags into a risk score using configurable weighting per signal type, producing a low / medium / high risk classification. High-risk claims are routed directly to the SIU queue with the full signal summary attached. Medium-risk claims are flagged in the adjuster's claim view with the signal list so the adjuster can apply judgment without the claim being pulled from their queue. Low-risk claims proceed normally. The SIU team reviews only the cases the agent has flagged, not every claim in the portfolio.

    The signal logic is transparent: the agent explains why a claim is flagged (specific signals, not a black-box score), which means the SIU reviewer starts their investigation knowing exactly what to look for. The workflow is built as a LangGraph directed graph with the signal checks as parallel nodes, so new signal types can be added without restructuring the workflow. Human escalation checkpoints are mandatory, the agent flags, it does not decide.

  6. Subrogation identification agent

    Subrogation recovery is money that insurers are entitled to but frequently leave on the table because identifying which closed or settling claims have a viable subrogation right requires reviewing loss circumstances, third-party involvement, and liability indicators that aren't always captured in a way that surfaces the opportunity. A subrogation identification agent reviews claims at defined points in the lifecycle and flags cases with recovery potential.

    The agent reviews the claim file at two trigger points: when liability indicators suggest a third party may be responsible (reported at FNOL or during adjustment), and when a claim reaches settlement or payment authorisation. At each trigger, the agent assesses the claim data: loss description and cause, third-party information captured in the FNOL or during adjustment, police or incident reports attached to the file, property damage assessments with causation noted, and any recorded statements. Using the LLM to analyse the unstructured narrative alongside the structured claim fields, it identifies whether the facts of loss indicate a third party's negligence or liability contributed to the loss.

    Claims where the analysis supports a potential subrogation right are flagged with a structured summary: the basis for the subrogation claim (the specific facts of loss and liability indicators), the applicable third party identified, any documentation already in the file that supports recovery, and documentation gaps that the adjuster should pursue before closing the claim. The flag routes to your subrogation unit or the handling adjuster, depending on your workflow configuration.

    The agent does not determine that subrogation exists, that is a legal and factual determination that a qualified professional makes. It identifies which claims in your portfolio warrant that professional review, so your subrogation unit focuses on the cases most likely to produce recovery rather than reviewing closed files manually or relying on adjuster initiative to flag opportunities.

Frequently asked questions

RPA and workflow automation follow fixed rules on predictable, structured data. If a FNOL arrives in a format the rule expects, automation processes it. If the format changes, a new email template, a new field in the web form, a free-text description instead of a structured form, automation breaks and requires a developer to fix it.

AI agents handle unstructured variation. A FNOL agent can extract the relevant data whether the claim comes in via a formal ACORD-aligned portal submission, a free-text email from a policyholder, a phone transcript, or a PDF attachment, because the LLM reads intent and content, not just field positions. The agent applies configurable validation rules after extraction, so it's not making up data, it's extracting what is present and flagging what is missing.

The second difference is that agents can take multi-step actions across systems. An RPA bot can copy data from one system to another. An agent can query your policy administration system to validate the FNOL policy number, create the claim record in your claims platform, route it to the right adjuster queue based on claim type and value, and send the initial acknowledgement, as one end-to-end workflow, with the state tracked and auditable throughout. If any step fails, the agent logs the failure and routes the exception to a human with full context, rather than silently dropping the transaction.

The right choice depends on the workflow. RPA is the right tool when inputs are structured and predictable. AI agents are the right tool when inputs vary, when the workflow requires reading and interpreting unstructured content, or when you want the system to handle variation gracefully rather than breaking.

Insurance AI agent builds require the same controls as any system handling policyholder data: data minimisation (the agent retrieves only the fields the workflow requires), encryption in transit (TLS 1.2 minimum) and at rest (AES-256), and access controls preventing the agent from reaching data outside its defined scope. Every action the agent takes is logged: what data it retrieved, what decision it made, what it wrote back to the system of record, and when. This audit trail is the compliance record.

The LLM API question is the one most teams don't think about until too late. Standard consumer API terms for OpenAI, Anthropic, and Google do not include the data processing agreements required for policyholder data in regulated markets. We document which API endpoints receive policyholder data and confirm appropriate data processing agreements are in place before any policyholder data flows to an LLM API. Enterprise tiers of major LLM providers offer the required agreements. Where data classification requirements mean no policyholder data can leave a defined boundary, the architecture uses a private LLM deployment within your infrastructure instead.

Human-in-the-loop checkpoints are not optional for high-stakes insurance decisions. The fraud signal flagging agent flags claims, it does not decide fraud. The subrogation identification agent flags recovery candidates, it does not initiate recovery. The FNOL intake agent creates and routes claims, it does not adjust or settle them. The boundary between what the agent handles autonomously and what it escalates is defined and configurable, and we document it explicitly in the scope and acceptance criteria so both sides know exactly where the human decision sits.

We deliver a data flow diagram, a controls inventory, and the audit trail specification alongside the working software, so your compliance team has what they need for their own risk assessment without having to reverse-engineer the architecture from the code.

We integrate with policy administration systems and claims platforms that expose REST APIs or SOAP web services. Guidewire PolicyCenter and ClaimCenter are the most commonly requested in the carrier market, Guidewire exposes REST APIs for both products, and the integration scope depends on which API capabilities your Guidewire configuration has licensed. Duck Creek Policy and Claims similarly expose REST APIs, with configuration determining which operations are available via API versus UI-only. Applied Epic and Applied TAM are common in the broker and MGA market.

For bureau data, CLUE (Comprehensive Loss Underwriting Exchange) reports are typically accessed via LexisNexis Risk Solutions or ISO (Verisk) API integrations, subject to the permissible purpose authorisation your organisation holds. MVR access varies by state and country, in the US, MVR retrieval typically runs through a motor vehicle record aggregator that holds the state-by-state credentialing. For UK carriers, CUE (Claims and Underwriting Exchange) access runs through MIB Group. We scope and confirm bureau API access during discovery, assuming access without confirming it is where integration timelines slip.

For ACORD-aligned data exchange, where your trading partners or reinsurers use ACORD XML for structured data exchange, we integrate the agent's output into the ACORD-format feeds where applicable. For legacy systems that expose neither REST APIs nor web services, file-based integration (SFTP plus structured file import) is the fallback, slower, but functional.

Integration complexity is the single biggest variable in project scope. We confirm API access, sandbox environments, and data model documentation during discovery before committing to a delivery timeline, we've seen too many insurance integration projects where the API access was assumed to exist but turned out to require a separate vendor approval process that added weeks to the timeline.

A focused insurance AI agent, one workflow (for example, a FNOL intake agent covering email and portal channels, or a claims status agent integrated with one claims platform), one system integration, defined escalation logic, and compliance-aware architecture, typically runs in the range of $35,000--$75,000 and delivers in 10--14 weeks. This includes the LangGraph workflow implementation, system integration, human-in-the-loop checkpoint design, audit trail, and compliance documentation (data flow diagram, controls inventory, escalation logic specification).

A multi-agent build covering FNOL intake, underwriting data extraction, and claims status with integrations to a policy admin system and claims platform, plus bureau API integrations for CLUE and MVR, typically runs $75,000--$150,000. The higher end applies when bureau credentialing timelines are uncertain or when the claims platform integration requires a custom middleware layer because the native API surface is limited.

Cost is driven by the number of system integrations, bureau access complexity, the volume of exception conditions the agent needs to handle, and how much of the workflow requires custom decision logic versus standard routing rules. We scope and price every project before starting, and the scoping document defines the workflow state machine, the integration points, the escalation logic, and the acceptance criteria so both sides know exactly what is being built and what it will cost.

We don't start a build we haven't scoped. That's the protection on both sides.

Yes. The FNOL intake agent is designed to accept input from multiple channels because that is how FNOL actually arrives. Policyholders don't always use the channel you've designed for them.

For email FNOL, the agent monitors a designated inbox (via IMAP or an email API integration), retrieves new messages, and runs extraction against the email body and any attachments. PDF or image attachments go through an OCR step before LLM extraction. For web portal submissions, the agent receives a webhook notification or polls the portal API for new submissions in structured JSON or XML format, less extraction needed because the fields are already defined. For phone transcripts, the agent receives the transcript text (from your IVR or a call recording transcription service) and extracts the FNOL fields from the unstructured conversational text.

Each channel feeds the same downstream validation and routing workflow. The claim record created in your system of record looks the same regardless of which channel the FNOL came through, which means your adjusters receive a consistent, structured claim file rather than a mix of formatted submissions and forwarded emails.

The channel mix we build for depends on your actual inbound FNOL distribution. If 80% of your FNOL volume arrives by email and 20% by portal, we scope and test those two channels thoroughly. Adding phone transcript processing is scoped separately because the extraction from conversational text has different edge cases than extraction from structured form submissions or email text. We confirm the channel scope during discovery so the agent is tested against real examples of what your inbound FNOL actually looks like, not a generic insurance template.

What clients say

What our clients say

Three-year average engagement. Founders and operators describing the work in their own words. No marketing varnish.

Charles E.
Charles E.
USA flagUSA
Entrepreneur at Aggie Technologies

All of the sprints were completed on schedule and on budget. We highly recommend RaftLabs!

Related services

  • Insurance Software Development, Custom policy management, claims platforms, InsurTech MVPs, and AI fraud detection for carriers and MGAs
  • Insurance Automation, Rules-based automation for claims intake, policy renewal processing, and regulatory reporting
  • AI Agent Development, AI agents for any workflow where unstructured inputs, multi-step actions, and cross-system integration are required
  • Business Process Automation, End-to-end process automation covering intake, routing, status management, and reporting
  • Insurance Fraud Detection, Anomaly scoring and fraud pattern detection built into your claims and underwriting workflows

Talk to us about your insurance AI agent project.

Tell us the workflow you want to automate, the systems you run on, and where your team is losing time to work an agent should handle. We'll scope what it takes and give you a fixed cost.

  • Scope and cost agreed before work starts. No surprises. No obligation.
  • Working prototype within 3 weeks of kickoff.
  • Pay by milestone. You see progress before each invoice.
  • 60-day post-launch warranty. Bug fixes, UI tweaks, and deployment support. No retainer.
  • All conversations are NDA-protected.