Claim Processing Agent
Auto-insurance claim decisions grounded in the policy, with business rules in the graph.
An agentic RAG system that validates an auto-insurance claim against policy records, retrieves the relevant policy language, checks the claimed repair cost against market estimates, and returns a structured, explainable coverage decision — through two interchangeable agent frameworks.
- automated tests across five modules
- 58
- interchangeable agent pipelines
- 2
- nodes in the LangGraph workflow
- 8
- configurable cost-inflation threshold
- 40%
Why it exists
Most auto-insurance claims follow the same path: is the policy real and active, is the incident covered, is the amount reasonable, what does the policy say about deductibles and limits? Adjusters spend much of their time on that routine path, and inconsistency creeps in when the same questions are answered by different people reading long policy documents.
The aim was a claim agent whose decisions are grounded in the policy text, whose business rules are explicit rather than buried in a prompt, and whose output is structured enough to audit.
How it works
- 01 Input Claim (JSON)
- 02 Code Validate against records policy, premium, dates
- 03 Model / AI Retrieve policy language ChromaDB semantic search
- 04 Check Market price check flags inflated repair costs
- 05 Model / AI Coverage decision structured output
- 06 Output Decision + reasoning trace
- Validation is plain code. Policy existence, premium status and coverage dates are checked against policy records before any model is involved; an invalid or expired policy ends the run with a clear reason.
- Agentic RAG over the policy. Relevant policy language is retrieved from a ChromaDB vector store and given to the model with the claim.
- A market price check. A web search estimates typical repair costs for the described damage; claims more than 40% above the estimate are routed to a separate “inflated” outcome. The threshold is configuration, not prompt text.
- Structured decisions. The result is a typed
ClaimDecision— covered or not, deductible, recommended payout and explanatory notes — with a reasoning trace shown in the interface.
The same domain logic runs through two interchangeable pipelines — a stateful LangGraph graph and an autonomous Smolagents agent — selected with a single configuration switch, which makes the frameworks directly comparable on identical inputs.
Results and honest limits
- Tests: 58 automated tests across schemas, validation, retrieval, both pipelines and the API.
- Scenario fixtures: valid claims, expired policies, invalid policies and inflated repair costs, so every branch of the graph is exercised.
- Delivery: FastAPI backend, Streamlit interface with a reasoning-trace viewer, Docker Compose deployment and Hydra-based configuration.
Engineering decisions
- Business rules as graph edges. Policy validity and the cost-inflation threshold are conditional edges in the LangGraph workflow, so they are visible, testable and changeable without touching prompts.
- Framework-agnostic core. Validation, ingestion and retrieval are plain Python functions shared by both pipelines — no logic is duplicated per framework.
- Externalized configuration. Models, thresholds and the pipeline choice live in Hydra config, so a change of behavior is a reviewed config change.
- Load-or-build vector store, so policy retrieval is immediate after the first ingestion run.
Who it’s for
For insurers and claims-operations teams, it shows how to automate the routine path of adjudication while keeping every decision traceable to policy language and explicit rules. For AI engineers, it is a side-by-side comparison of a stateful graph and an autonomous agent on the same task.
