ClaimSense

We started ClaimSense for a hackathon.

The hackathon came with constraints, including which LLMs we could use.

That was fine for getting something working quickly.

But we wanted to build the best version of the product, not the best version we could build within the rules of the hackathon.

So we left the hackathon and rebuilt it.

The idea

Insurance and government healthcare claims come with a lot of documents.

A missing document.

The wrong package.

A date that doesn’t make sense.

An extra document that shouldn’t be there.

A required piece of clinical evidence that isn’t there.

Most claim checks ask whether a document exists.

ClaimSense asks something closer to what an auditor actually asks.

Does this claim tell one consistent story?

The idea was never to replace the auditor.

It was to catch what we could catch before the auditor had to.

What exists today

ClaimSense currently works with PMJAY claim documents and the four packages we built for the NHA hackathon:

• Enteric fever
• Severe anemia
• Cholecystectomy
• Total knee replacement

We want to keep building it as an internal tool first, using our own claim documents, before anyone else does.

It reads a claim page by page, understands what each page contains, and checks the complete claim against what the package actually requires.

The output is a single decision.

PASS. FAIL. CONDITIONAL.

Every rule inside it exists because a real claim broke on it first.

How it works

A claim arrives as a folder of hospital documents.

ClaimSense doesn’t immediately send the entire folder to an LLM.

It starts with the simplest question.

What is this page?

If the system can answer that deterministically, it does.

If it can’t, the page goes to Claude’s vision model.

Once the pages are understood, ClaimSense combines them into a single claim.

It checks what package was submitted.

It extracts the clinical and administrative information that matters.

It reconstructs the treatment timeline.

It runs the package-specific rules.

And then it produces one decision.

Claim documents
        ↓
Page classification
        ↓
Document understanding
        ↓
Structured claim data
        ↓
Claim + package validation
        ↓
Treatment timeline
        ↓
Package rules
        ↓
PASS / FAIL / CONDITIONAL

The important part is that the decision comes last.

Design principles

ClaimSense is built around a few principles that influence almost every decision.

Rules first. AI second.

If a page can be identified without a model, it should be.

AI is for the pages that are genuinely hard to read, not for the ones that are just familiar.

Every answer keeps its evidence.

An extracted value is only useful if it can be traced back to the page and the evidence that produced it.

The system keeps that provenance even when it isn’t shown in the final output.

The package is not a fact.

What a hospital submits and what the documents actually describe aren’t always the same thing.

ClaimSense checks.

AI understands. Rules decide.

The model reads the documents.

It doesn’t decide whether a claim passes.

Extra is not missing.

A claim can contain documents that aren’t required by its package.

Those documents are identified as extra rather than being silently ignored or treated as missing evidence.

The timeline matters.

Dates aren’t just fields to extract.

They describe what happened and when.

ClaimSense reconstructs the treatment timeline so that admission, treatment, procedures and discharge can be checked as one sequence.

Built at Halfwrong, the studio I co-founded with Tejas Gurav.