Inspiration
Access to healthcare doesn't end at getting insured. In the US about one in five in-network claims is denied, and fewer than one in a hundred is ever appealed. Roughly one in nine claims is rejected in India, and two thirds of UK disability denials are overturned once a judge actually looks. People don't lose because the law is against them. They lose because nobody builds the case: it takes reading policy language, finding the right statute, and writing a formal appeal, and most patients can't do that while sick.
We wanted to build the person who builds the case.
What it does
When a claim is denied, four AI agents take it to a tribunal in one shared room:
- Advocate argues for the patient, using the records and policy language that support coverage.
- Scrutinizer argues the insurer's side and probes for missing documentation, exclusions and step-therapy gaps.
- Evidence stays neutral and produces the exact document or statute that settles a disputed fact.
- Adjudicator chairs the hearing and recommends a ruling.
They read and rebut each other instead of passing tasks down a line. A person reads the whole debate and delivers the decision (overturn, uphold or remand). The AI argues. A human rules. Every ruling cites its authority; the sample cases rest on real law: ERISA's full-and-fair-review rule (29 C.F.R. § 2560.503-1), the ACA's external review (45 C.F.R. § 147.136), Jimmo v. Sebelius and the No Surprises Act.
For access, the Chamber can read the hearing aloud with the browser's built-in speech, so someone who can't comfortably read a long legal debate can listen to it.
How we built it
- The Chamber (web): Next.js 16, React 19 and Tailwind. It plays labelled sample hearings entirely in the browser, with no API call and no database. An invite-only live hearing runs on Groq's free tier, driven by server-signed continuations so the browser can't edit the transcript.
- The Band tribunal (agents): each role is its own Python process, connected to one shared room on Band over WebSocket, built on LangGraph. They coordinate by
@mentioningeach other. - Tamper-evident transcript: each stored turn's hash covers the previous hash, so editing an earlier turn breaks the chain:
$$h_i = \mathrm{SHA256}(h_{i-1} \,|\, \mathrm{canonical}(turn_i))$$
- Free by design: paid providers are switched off in code, even if API keys are present. Anyone can run it at no cost.
Challenges
- Getting a clean debate. A mention-driven debate stalls when a model hands off to the wrong agent, and goes silent when it returns its ruling as plain text instead of posting it. We wrote a deterministic relay: code forces every handoff and posts the model's text itself if the send tool was skipped. The models write only the arguments.
- Free-tier limits. Rate limits are waited out, a used-up quota pauses the hearing with a notice to the reviewer, and a failure after an agent has posted is never retried, so turns aren't duplicated.
- Honest guarantees. The hash chain covers turns only, and anyone who can rewrite the database can recompute it. We call it tamper-evident, not tamper-proof, and rulings are not identity-verified.
What we learned
Let models argue and let code run the process. Reliability in multi-agent systems came from deterministic orchestration, not from better prompts. We also added local telemetry (tokens, retries, rate-limit waits, wall-clock time per hearing) so we could measure what a hearing costs.
What's next
- Multilingual hearings, so patients can follow the debate and receive the appeal in their own language.
- Real denial letters in place of synthetic sample cases.
- Published checkpoints for the hash chain and verified reviewer identity.
Built With
- groq
- langchain
- langgraph
- microsoft-band
- nextjs
- pytest
- python
- react
- sha-256
- sqlite
- tailwindcss
- typescript
- vercel
- web-speech-api
- websockets
