ClaimCourt — Adversarial Claims Arbitration

Inspiration

Insurance claims get reviewed by one party — the insurer — whose financial incentive is to deny or reduce. The claimant gets the answer, not the reasoning. When something feels wrong, the only recourse is months of appeals or a lawyer most people can't afford.

I kept thinking: what if both sides got an advocate before a human ever touched the file? Not to replace the adjuster — to make sure the adjuster sees the strongest version of each argument before deciding. The job of the human shifts from finding the answer to judging between two well-prepared cases. That's the job humans are best at, and the job AI agents are uniquely positioned to set up.

That's ClaimCourt — an adversarial multi-agent system where one AI argues to deny the claim, one argues to approve it, an arbiter synthesizes the debate, and a human adjuster makes the call.

What it does

ClaimCourt runs every incoming insurance claim through a structured debate:

Intake parses the raw claim (email, PDF, form) into a structured record. Triage scores complexity and routes — simple claims skip the full debate. Medical Evidence pulls and summarizes records for personal-injury claims. Insurer Advocate and Claimant Advocate argue in parallel: one finds every reason to deny or reduce, the other finds every reason to approve in full. Arbiter synthesizes both arguments into a single recommendation with explicit trade-offs. Human adjuster sees both sides and the arbiter's view in UiPath Action Center, then decides. The decision, full debate transcript, and reasoning are persisted to the case record for audit. The whole thing is orchestrated by UiPath Maestro Case — every stage, every agent call, every human task is a tracked step in one durable case.

How we built it

Solo build over seven weeks, with Claude Code as a force multiplier for boilerplate, schema design, and prompt iteration.

Orchestration spine. UiPath Maestro Case sits at the center — it gives me long-running state, human-in-the-loop tasks, and full auditability out of the box. Every claim is a case; every agent call is a tracked stage; every human decision is a persisted task. I never had to write workflow plumbing.

Multi-framework agent roster — deliberate, not accidental. Each agent runs on the framework that's best at its specific job:

Intake Agent — built in UiPath Agent Builder with Document Understanding. The platform's native PDF and email parsing is hard to beat, and keeping intake inside UiPath means the structured record flows straight into Maestro. Medical Evidence Agent — built in LangChain. Tool use plus mock FHIR retrieval is LangChain's sweet spot, and I wanted clean control over the retrieval chain for personal-injury claims. Insurer Advocate and Claimant Advocate — both built in CrewAI. The role-based agent definition fits the "advocate" mental model perfectly, and using the same framework for both sides keeps the debate symmetric — the only thing that differs is the system prompt and the goal. Arbiter Agent — back in UiPath Agent Builder for native Maestro integration on the synthesis step, since the arbiter's output is what drives the human task. That's five agents across three frameworks, all coordinated by one Maestro Case.

Surrounding UiPath services. API Workflows handle the agent invocation calls. Action Center hosts the human adjudication task with both arguments and the arbiter's recommendation laid out side-by-side. Data Service persists the case record and the full debate transcript for audit. Document Understanding handles the messy first-mile claim intake.

The contract that holds it together. With five agents writing into one case, the ClaimCaseRecord Pydantic schema became the project's most important file. Every agent reads a known slice of the record and writes a known slice back. Frameworks are interchangeable; the schema isn't. That discipline is what made multi-framework feel like one system instead of three duct-taped together.

Challenges we ran into

Getting agents to actually disagree. My first prompt pass gave me two advocates who politely agreed on everything. I had to push hard with role conditioning, explicit "your job is adversarial — find the strongest argument for your side even if you doubt it" framing, and forbidding hedging language. The debate only works if both sides commit.

Orchestrating across three frameworks inside one Maestro Case. Each framework expects to own the agent loop. Getting them to behave as steps inside a longer process — passing structured records in and out, surfacing intermediate state to Maestro — was the hardest engineering work in the build.

Schema discipline. With five agents writing to one case record, the ClaimCaseRecord Pydantic schema became the contract. Every agent reads and writes a known slice. Without that, I'd have spent the build debugging shape mismatches.

Solo + first hackathon. No teammates to bounce ideas off, no one to catch scope creep. I locked the cut order on day one (which features get dropped first if I slip) and it saved me twice.

Accomplishments that we're proud of

What we learned

Maestro Case is the right shape for agentic workflows. Long-running, human-in-the-loop, auditable. I'd reach for it again over a stateless agent loop. Adversarial framing surfaces failure modes that single-agent review misses. When an advocate is required to argue one side, weak evidence gets exposed by the other side immediately. The human-in-the-loop step is the product, not the safety net. Adjusters don't want "AI decided" — they want "AI prepared both arguments so I can decide faster." Framing matters. Multi-framework is achievable when the case record is the contract. Frameworks are interchangeable; the schema isn't.

What's next for ClaimCourt — Adversarial Claims Arbitration

Real FHIR integration (currently mocked) for the Medical Evidence agent. Expand beyond personal-injury claims into property and auto. Adversarial calibration — track when the Arbiter sides with which advocate and audit for systematic bias. A claimant-facing view so the policyholder sees the Claimant Advocate's argument too, not just the decision