Coverage Keeper

Inspiration

During the 2023 Medicaid “unwinding”, about 72–73% of people who lost coverage lost it for procedural reasons: a form not returned, a document not received, a deadline missed. Many of them still qualified.

That problem is about to grow. From January 2027, Massachusetts Medicaid (MassHealth) adds federal work requirements and six-month renewals for expansion adults. About 360,000 members will be subject to the new checks, and the state estimates around 175,000 people could lose coverage. Many will be working or exempt, and will lose coverage anyway because proving it is hard.

The people standing between those members and a coverage gap are navigators and care coordinators. They are already stretched, and they now face complex new rules, twice-yearly renewals and members who speak many languages. Existing tools send reminders. We wanted to build something that actually finishes the paperwork, while keeping the navigator in charge.

What it does

Coverage Keeper gives navigators AI agents that take a member’s renewal notice and documents and turn them into a verified, ready-to-review response.

Every case lands in one of three outcomes:

Retain: eligible members at risk. Coverage Keeper finds the pathway their documents support, catches missing evidence and drafts the response before the 30-day deadline.
Recover: members already dropped for paperwork. While the 90-day reconsideration window is open, it counts down the days and drafts the submission, so they may regain coverage without reapplying.
Transition: members who may no longer qualify. It lists next-coverage options neutrally, calculates the date to enroll by to avoid a gap, and prepares a hand-off note.

The navigator’s workflow:

Today shows every member who needs action, sorted by soonest deadline, with one clear next step and a visual timeline for each.
Members lists the roster in three views (at risk, dropped, likely to lose eligibility), showing due dates, reconsideration windows and enroll-by dates.
Case shows a member’s recommendation, documents, drafted letters, evidence, and exactly how each decision was reached.

In our demo, Maria is a Spanish-speaking caregiver whose renewal notice arrived in English. Coverage Keeper finds she is likely exempt as a caregiver, then catches the detail a reminder system never would: her mother’s doctor’s letter names the stroke but never states a disability. It holds the packet, drafts a request to the doctor quoting the federal definition, and explains everything to Maria in Spanish.

Every sentence the system writes is cited to a document line and a rule. It never decides eligibility, and nothing is sent until a navigator approves it.

How we built it

Agents. Eleven specialised agents run in sequence: risk check, outreach, intake, extraction, rules, gaps, outcome, follow-up, drafting, verification and translation. Anything that must be exact, such as dates, ages, thresholds and deadlines, is plain code. Language models handle what code can’t: reading messy documents, interpreting doctors’ letters, drafting and translating. Every model-backed agent has a rule-based fallback, so a run always completes.

Grounding and verification. Extracted facts must quote their source verbatim, or they are dropped. Drafts are built from typed claims, and a verifier checks each one for a real quote, a valid rule, matching numbers and no eligibility-decision language, plus a model entailment check in live mode. Unsupported claims are removed and logged.

Policy packs. All program knowledge (pathways, thresholds, evidence rules, deadlines, transitions and a rulebook quoted verbatim from the federal regulation) lives in swappable configuration files. Supporting a new program is a new pack, not new code. We proved it by running an illustrative employer-plan pack through the same agents.

Models. A single gateway supports Anthropic, NVIDIA NIM, Groq, Gemini, Cerebras and OpenRouter, with JSON-schema enforcement, rate pacing, response caching and cost metering. Drafting, verifying and judging use different model families, so the checker doesn’t share the writer’s blind spots. A replay mode runs the whole demo offline.

Stack. Python and FastAPI on the backend, with live agent progress streamed to the browser over server-sent events. The frontend is a dependency-free single-page app in native JavaScript modules.

Data and evaluation. We generated 54 labelled synthetic cases full of edge cases, rendered every document as a realistic PDF, and built a 200-member roster calibrated to real CMS renewal outcomes and US Census language data. A one-command evaluation harness scores accuracy, safety and fairness.

Challenges we ran into

Realistic documents broke us at first. When we rendered our documents as realistic PDFs, naive text extraction split form labels from their values, and accuracy dropped from 46 of 46 cases to 28. We wrote layout-aware extraction that rebuilds each visual line, which restored full accuracy.

Open models and structured output. Several hosted models returned errors, timed out, or wrapped their JSON in reasoning text and code fences. We built defensive parsing, a schema-conformance layer and per-provider rate pacing, and selected models only after they passed a strict schema test.

Official sources we couldn’t reach. Some state pages blocked automated access. Rather than guess, we quoted federal rules verbatim, checked them automatically against the source text, and marked every rule we couldn’t confirm as “needs confirmation” throughout the interface.

Realistic data without real patients. Member-level Medicaid data is protected health information. We calibrated our synthetic roster to published, area-level CMS and Census data instead, so its shape is real even though no real person appears.

Being helpful without overstepping. The hardest design problem was not technical: how to help members as much as possible without ever implying an eligibility decision, promising reinstatement, or steering someone toward a particular plan. We had to enforce those boundaries in code, not just in prompts.

Shipping as a team under time pressure. Several of us worked in parallel on the same files, on a shared computing cluster, against a hard deadline. Merge conflicts and environment quirks taught us to keep changes small and merge often.

Accomplishments that we’re proud of

An end-to-end system that goes from a renewal notice to a cited, verified response packet, letter and member explanation, with a human approving every step.
On our held-out test set: 100% pathway, gap, outcome and deadline accuracy; 0% of members falsely reassured or wrongly redirected; and 0 of 429 drafted claims unsupported. We’re equally proud of being upfront that these are upper bounds on synthetic data.
A risk ranking that finds 80% true at-risk members in its top 20, compared with 15% for “soonest deadline first”.
Catching the kind of gap that actually costs people coverage, such as a doctor’s letter that is almost, but not quite, enough.
A policy-pack design where a completely different program runs through the same agents without any code changes.
A demo that runs fully offline, and models that can be swapped between commercial, open-weight and free providers.

What we learned

Most of the value is in the boring details. The difference between keeping and losing coverage is often one missing sentence or one missed date. Getting those exactly right mattered more than any clever prompt.
Let code decide and models interpret. Language models are excellent at reading and writing, but deadlines and thresholds belong in deterministic code that can be tested.
Verification is a feature, not overhead. Grounding every claim made the system more trustworthy, and also much easier to debug.
Evaluate honestly. Building the evaluation harness early kept us honest, and showed us exactly where our rule engine would and wouldn’t generalise.
Design for the person using it. Navigators need a clear next action and a deadline, not more data. Re organizing the interface around “what do I do today?” changed the product more than any new feature.

What’s next for Coverage Keeper

Pilot with navigator teams on de-identified real documents, to measure accuracy on real-world scans, handwriting and noise.
Document intake and policy matching: we’ve prototyped encrypted document upload, automatic checks for missing, expired or mismatched documents with suggested corrections, and matching of members to policies by age, nationality, residence, timeline and insurance tier.
More programs: new policy packs for Medicare Advantage, marketplace re-enrollment and other states’ Medicaid programs as their work requirements roll out.
More languages, driven by local need, starting with Khmer, which our calibration data showed is common among limited-English residents in Lowell.
Confidence-aware review, routing low-certainty extractions directly to a navigator.
Integration with health plans’ existing case-management systems, so Coverage Keeper fits into the tools navigators already use.