Inspiration
When you receive a medical bill, how do you know the amount is correct?
Your insurance company sends an Explanation of Benefits (EOB). Your hospital sends another bill. Somewhere in a long insurance contract are the rules that determine what you actually owe.
But patients are rarely equipped to verify those calculations themselves.
We built Fineprint to change that.
Instead of asking patients to blindly trust the insurance company, we give them the tools to check the numbers, understand the rules, and challenge possible billing errors with evidence.
What it does
Fineprint is an independent medical insurance bill auditor.
It follows the patient's actual journey through three steps:
- Insurance Policy: Read the contract and extract the rules for deductibles, copays, coinsurance, and out-of-pocket limits.
- Insurance Claim (EOB): Independently calculate the patient's responsibility and compare it against the insurer's numbers.
- Medical Bill: Reconcile the final charge, account for previous payments, and identify possible overcharges.
Every discrepancy is connected to a specific policy clause, so patients can understand not only how much differs, but why.
For example, in one fictional demonstration:
- Insurance EOB: $465 patient responsibility
- Hospital Bill: $505 charged
- Fineprint Calculation: $385 expected responsibility
- Potential Overcharge: $120
Instead of simply declaring the bill incorrect, Fineprint shows the calculation, identifies the relevant policy clauses, and produces an evidence-backed summary that patients can use when contacting their insurer or provider.
How we built it
We designed Fineprint around one principle: AI should interpret the rules, but deterministic software should calculate the money.
Our architecture separates the system into several components:
1. Policy Compiler
A Python-based compiler transforms insurance policy language into structured, executable rules.
It supports deterministic parsing and optional LLM-based extraction, including an AWS Bedrock integration path.
2. Evidence Verification
Every extracted rule retains a reference to the exact text that supports it.
Schema validation and source-span verification help prevent unsupported or hallucinated rules from entering the calculation engine.
3. Independent Calculation Engine
We built a deterministic calculation engine that handles deductibles, copays, coinsurance, and out-of-pocket limits using integer-cent arithmetic.
Financial calculations do not depend on an LLM generating numerical answers.
4. Claim and Bill Reconciliation
The system independently recalculates patient responsibility and compares the result against both the insurer's EOB and the medical provider's bill.
Discrepancies are reported with supporting evidence and calculation details.
5. Deployment and Visualization
We containerized the Python application with Docker and deployed it on AWS.
We also built an interactive case explorer using GitHub Pages, allowing users and judges to inspect sample cases, calculations, and evaluation results.
Challenges we ran into
The hardest challenge was not extracting information from insurance documents. It was determining whether the extracted information could actually be trusted.
Insurance contracts contain exceptions, conflicting clauses, ambiguous definitions, and missing information.
An AI-generated interpretation can sound completely convincing while producing an incorrect financial result.
We addressed this challenge by:
- Separating language interpretation from financial arithmetic.
- Requiring policy rules to reference their original source text.
- Validating structured outputs before calculations.
- Detecting missing or ambiguous information instead of inventing answers.
- Building evaluation cases that expose failures rather than hiding them.
Another significant challenge was evaluating the system honestly. Real insurance policies are much more complex than simplified demonstration documents, and our experiments revealed limitations in both deterministic parsing and LLM-assisted extraction.
These findings helped us identify where the system is reliable and where further development is necessary.
Accomplishments that we're proud of
We are especially proud that Fineprint is more than a chatbot that explains insurance terminology.
It is a working prototype of an independent verification system.
Our accomplishments include:
- Built an end-to-end workflow covering insurance policies, EOB calculations, and medical bill reconciliation.
- Developed a deterministic financial engine independent of AI-generated arithmetic.
- Implemented source-level evidence tracing for extracted insurance rules.
- Created three interactive synthetic demonstration cases covering billing discrepancies and ambiguous policy scenarios.
- Built an automated testing suite containing 104 tests.
- Achieved exact end-to-end results on 8 of 10 authored synthetic benchmark cases using the offline parser, including 2 of 4 held-out cases.
- Deployed the application to AWS.
- Published an interactive website documenting demonstrations and evaluation results.
These results represent prototype testing on synthetic data, not validated accuracy on real-world medical claims.
Most importantly, we demonstrated that AI can help patients understand and challenge complex financial decisions without requiring them to blindly trust another black-box system.
What we learned
We learned that trustworthy AI is not about producing the most confident answer. It is about making the answer verifiable.
Large language models are powerful tools for understanding complicated documents, but they should not be treated as unquestionable authorities, especially when real money is involved.
By combining AI-assisted interpretation, deterministic computation, and traceable evidence, we explored a different approach to building practical AI applications.
We also learned that sometimes the most responsible answer is not a dollar amount.
It is an explanation of what information is missing, why the calculation cannot be completed, and what the user needs to verify next.
What's next for Fineprint
Our long-term vision is to make Fineprint a practical tool for patients navigating medical expenses.
We plan to expand the project in several directions:
- Real-world document support: Handle uploaded PDFs, complex insurance contracts, and different EOB formats.
- Improved AI extraction: Support more policy structures while maintaining strict evidence verification.
- Broader evaluation: Test against more representative insurance scenarios and consented, de-identified real-world cases.
- Privacy and security: Introduce stronger safeguards for sensitive personal and medical information.
- Patient advocacy tools: Generate actionable, evidence-backed summaries that help patients communicate with insurers and healthcare providers.
Our ultimate goal is simple:
Patients deserve to understand what they are paying for, why they are paying it, and whether the numbers are correct.
Fineprint — The fine print, finally on your side.
