AI Agents for insurance: How to Automate real-time decisioning (single-agent with LangGraph)

Insurance carriers lose money when routine decisions sit in queues: claim triage, policy underwriting referrals, fraud flags, and document checks all wait on humans. A single-agent setup with LangGraph is a good fit when you need one controlled decisioning workflow that can inspect context, call tools, apply rules, and return an auditable outcome in seconds.

The Business Case

• •

  Claims triage time drops from 15–30 minutes to under 2 minutes per file

  • •For FNOL intake, document classification, and severity routing, a single agent can pre-score the case and send it to the right adjuster or straight-through processing path.
  • •In a mid-size carrier handling 20,000 claims/month, that saves roughly 4,000–8,000 labor hours annually.
• •

  Underwriting referral volume can fall by 20–35%

  • •The agent can auto-check appetite rules, prior loss history, exposure limits, and missing information before a submission reaches an underwriter.
  • •That means fewer manual touches on standard personal lines and small commercial submissions.
• •

  Operational error rates usually drop by 30–50%

  • •Most avoidable errors come from copy-paste work: wrong policy effective date, missed exclusions, incomplete loss notes, or inconsistent referral reasons.
  • •A rule-backed agent reduces rekeying and makes every decision traceable.
• •

  Cost per decision falls materially

  • •If a manual claims review costs $8–$25 depending on complexity, an automated pre-decision step often brings that down to cents in compute plus a fraction of a minute of human review.
  • •The real savings show up in reduced leakage, fewer rework loops, and faster cycle times.

Architecture

A production-ready single-agent design should be narrow in scope. Do not build a general assistant; build one decisioning workflow with clear inputs, tools, and outputs.

• •

  Channel layer

  • •Intake comes from claims systems, underwriting portals, email parsing, or API events.
  • •Typical stack: Guidewire/Duck Creek integrations, Kafka for events, REST APIs for synchronous requests.
• •

  Agent orchestration

  • •Use LangGraph to define the workflow as a state machine: classify request, retrieve context, apply policy/rule checks, decide route, write audit trail.
  • •Use LangChain only for tool wrappers and prompt composition; keep the actual control flow in LangGraph so you can test transitions deterministically.
• •

  Knowledge and retrieval

  • •Store policy wording, underwriting guidelines, claims playbooks, SOPs, and regulatory guidance in pgvector or another vector store.
  • •Add structured lookups against policy admin data, billing status, prior losses, fraud indicators, and customer profile tables.
• •

  Decision layer

  • •Combine LLM reasoning with hard business rules.
  • •Example: if bodily injury claim exceeds reserve threshold or involves litigation language, route to senior adjuster; if commercial submission breaches appetite limits under $X revenue or class code restrictions, auto-decline or refer.

A simple flow looks like this:

Request -> Normalize -> Retrieve policy/rules -> Evaluate thresholds -> Decide route -> Log rationale -> Return action

For regulated environments:

• •Keep PII/PHI access scoped through least privilege.
• •Encrypt data at rest and in transit.
• •Log prompts, tool calls, retrieved documents, and final outputs for auditability.
• •If you touch health-related claims data in the US market, treat HIPAA controls seriously.
• •For EU customers or claimants, ensure GDPR data minimization and retention controls.
• •If your org already runs SOC 2 controls or maps to Basel III-style governance expectations in financial services groups with insurance arms, reuse those control patterns: access reviews, change management, incident logging.

What Can Go Wrong

The biggest mistake is letting the model make final decisions without guardrails. In insurance you need explainability first and automation second. A bad auto-decline is more expensive than ten minutes of manual work.

Getting Started

1. •

   Pick one narrow use case

   • •Good first candidates: FNOL triage for auto claims under a threshold amount; underwriting intake for small commercial submissions; document completeness checks.
   • •Avoid complex life/health adjudication or high-severity bodily injury decisions on day one.
2. •

   Assemble a small cross-functional team

   • •You need 1 product owner, 1 insurance SME, 1 backend engineer, 1 ML/agent engineer, and 1 risk/compliance partner.
   • •That’s enough to run a pilot without overbuilding governance too early.
3. •

   Build a 6–8 week pilot

   • •Week 1–2: map the current workflow and define decision criteria.
   • •Week 3–4: implement LangGraph states and tool calls.
   • •Week 5: connect retrieval over guidelines using pgvector.
   • •Week 6–7: add logging, redaction, schema validation, and fallback routing.
   • •Week 8: test on historical cases and compare against human decisions.
4. •

   Measure only business metrics that matter

   • •Cycle time
   • •Referral rate
   • •Straight-through processing rate
   • •Error/rework rate
   • •Complaint rate
   • •Human override rate

If the pilot does not reduce handling time by at least 30% while keeping override rates low and audit quality high، do not scale it yet. Insurance automation succeeds when it removes repetitive judgment work without weakening control. A single-agent LangGraph design is enough for that first step if you keep the scope tight and the governance strict.

Keep learning

• •The complete AI Agents Roadmap — my full 8-step breakdown
• •Free: The AI Agent Starter Kit — PDF checklist + starter code
• •Work with me — I build AI for banks and insurance companies

By Cyprian Aarons, AI Consultant at Topiax.