ClaimPilot
I built ClaimPilot to show what AI-powered claims triage could look like at Allstate. It's a working prototype where a Claude-powered agent classifies claims, verifies coverage, screens for fraud, and recommends next steps. The whole triage takes under 60 seconds.
This is an independent portfolio project, not affiliated with or endorsed by Allstate. Built with sample data only.
Claims Triage Is a Bottleneck
When a customer files a First Notice of Loss, the claim has to be classified, the policy verified, fraud indicators checked, and the claim routed to the right adjuster. That process typically takes 24 to 48 hours, and misrouted claims add 5 to 10 days on top of that. Allstate processes around 4 million claims a year, so even small improvements at this stage save real money.
24-48 hrs
Current triage time
~4M / year
Allstate claim volume
10-12%
Loss adjustment expense
A Multi-Step Agent, Not a Chatbot
The agent decides which tools to call and in what order, reasons between steps, and adapts based on what it finds. If the policy is expired, it skips fraud assessment and goes straight to denial.
Extracts claim type, severity, and key details from the free-text description.
- Claim type (auto, home, liability)
- Severity level (low to critical)
- Coverage area and key facts
Checks the policy to verify coverage, deductibles, limits, and status.
- Policy status (active, expired, cancelled)
- Coverage type and deductible
- Policy limits and effective dates
Evaluates fraud risk indicators and returns a risk score with specific red flags.
- Risk level (low, medium, high)
- Fraud score (0 to 100)
- Specific red flags identified
Recommends a resolution path and estimated payout range.
- Resolution path (approve, investigate, escalate, deny)
- Estimated payout range
- Recommended next steps
How It All Connects
Built with Next.js 16, TypeScript, Vercel AI SDK, Claude API, SQLite, and PostHog. View detailed agent workflow diagram
Why I Built This for Allstate
Each piece of ClaimPilot maps directly to a responsibility in the Digital Product Manager JD.
Product Direction
Product brief with scoped v1 roadmap, success metrics, and explicit non-goals.
I scoped this the way I'd scope a real product: what's in, what's out, and why. Not just a list of features.
Stakeholder & Demand Management
Decision log with 8 documented tradeoffs, each with context, options, and rationale.
Every entry is a tradeoff I actually had to make. These are the kinds of conversations I'd have with stakeholders at Allstate.
Problem Framing
Problem statement grounded in industry data: 24-48 hour triage, 5-10 day misroute delays, ~4M claims/year.
I started with the numbers, not a vague idea. The problem statement connects directly to measurable outcomes.
Data-Driven Decisions
Analytics dashboard with live metrics plus PostHog tracking with a documented analytics plan.
I can walk through what the dashboard shows and explain why each event is tracked. Every metric answers a specific product question.
User Experience
Streaming agent chat that shows each tool call as a card with inputs, outputs, and reasoning.
The UI makes the agent's thinking visible. That's a UX win for users and an auditability requirement for insurance.
AI Innovation
Multi-step Claude agent with 4 tools, Zod-validated I/O, and configurable escalation thresholds.
This isn't a chatbot wrapper. Claude decides which tools to call autonomously, and high fraud risk triggers human review instead of auto-resolving.
Tradeoffs I Made
I documented 8 decisions during the build. Here are four that shaped the product most.
Streaming tool-use over prompt chaining
I wanted the agent to be autonomous, not follow a fixed script. With streaming tool-use, Claude decides tool order based on what it finds. If the policy is expired, it skips fraud assessment and goes straight to denial. That's closer to how a real adjuster thinks.
Tradeoff
The UI gets more complex (rendering tool call cards with different states) and it's harder to test deterministically. Prompt chaining would have been faster to build.
"Triage assistance" not "claims automation"
No carrier will let AI auto-settle claims. Real claims involve negotiation, documentation, and regulatory compliance. I framed this as decision support because that's what an Allstate hiring manager would actually want to see, not a naive pitch about replacing adjusters.
Tradeoff
“Automated Claims Resolution” sounds more impressive on a resume. But credibility matters more than ambition here.
Four separate tools, not one big prompt
Real claims workflows have separate steps handled by different specialists. Splitting into four tools means each one is independently testable (18 unit tests), and the UI can show each step as its own card. You can actually see the agent think.
Tradeoff
More code, more complex orchestration. A single prompt would have been simpler, but it wouldn't demonstrate tool-use and you couldn't test the pieces independently.
Rule-based tool logic, not LLM-generated
The agent (Claude) decides which tools to call and interprets the results. But the tools themselves are deterministic: pure functions, no API cost, fully testable. In production you'd swap in ML models, but the architecture stays the same.
Tradeoff
Less accurate classification than an LLM could do. Worth it for consistent, testable results in a demo.
Full decision log with 8 entries available on GitHub
What the Data Shows
I ran 16 sample claims through the system. Here's what came back.
< 1s
Avg triage time
13%
Fraud flag rate
6%
Auto-resolution rate
18
Unit tests passing
Try it yourself
Load a sample claim, hit submit, and watch the agent work through it step by step.
Built with Next.js 16, TypeScript, Claude API, Tailwind CSS, shadcn/ui, SQLite, and PostHog.
Marcelo Otero
I'm a product manager who builds. At Marriott, I built an AI agent that turned Figma mockups and requirements into structured Jira stories. At Now Optics, I shipped an order status tool that handled 675K+ lookups and cut call center inquiries by 60%. ClaimPilot is one of several products I've independently shipped using Claude Code, Next.js, and AI APIs.