CarePath Navigator

Inspiration

A huge number of uninsured and underinsured young adults such as students, recent grads, part-time and gig workers never get healthcare support they could access, not because they don't want it, but because the system is confusing. Medicaid, ACA Marketplace subsidies, sliding-scale clinics, hospital charity care, and CHIP each use their own jargon, income thresholds, and household rules. Faced with that, many people simply give up. We wanted to move someone from "I have no idea where to start" to "Here are the options I may be able to explore, why they showed up, what I still need, and what to do next."

What it does

CarePath Navigator is a decision-support web app, not a directory and not a chatbot. A guided, privacy-conscious intake collects only what's needed (state, household size, income, income type, insurance status, dependents, urgency). An NLP-style layer interprets messy real-life answers - like variable gig income - into structured data and flags ambiguity. A deterministic rules engine then produces cautious results grouped as "You may qualify," "Possibly eligible - verify," and "Likely not eligible -alternative." Every result card explains why it appeared, shows a confidence level with a breakdown of what raised or lowered it, lists the missing information to verify, and gives one concrete next step. The app then builds a personalized verification roadmap, a copy/print action-plan checklist, and an auto-filled caseworker script and routes the user to official sources and real people for the final decision.

How we built it

React 18, Vite, and TypeScript with Tailwind CSS, no backend, no database, no login - so it runs locally with npm install and npm run dev and demos reliably offline. The core is a hybrid architecture: an NLP/interpretation layer wraps a deterministic rules engine on both sides (normalize messy input before the rules, explain results in plain language after). The rules engine is the single source of every verdict label, using clearly-commented synthetic Federal-Poverty-Level-style thresholds. A code-enforced guardrail scans all user-visible text and neutralizes over-promising phrasing, backed by an automated test suite. A "Mock AI Mode" runs everything deterministically with no API key for a dependable live demo; an optional "Real LLM Mode" can produce the same structured output for the explanation layer only, with a safe fallback so the app never breaks.

Challenges we ran into

The hardest design tension was being genuinely helpful without ever overstepping into a false eligibility promise. We solved it architecturally: the language layer can never set a verdict - only the auditable rules engine can - and a guardrail enforces cautious wording in code rather than relying on prompts. Handling variable, uncertain income honestly was another challenge; instead of faking a single number, when income is variable or unsure, we ask for a typical low–high range instead of a single number, annualize it, mark it uncertain, and lower confidence, we annualize a range, mark it uncertain, and lower confidence so the user sees the uncertainty. We also had to detect immigration-related concerns in free text to route people to human help without ever asking for or classifying immigration status.

Accomplishments that we're proud of

A complete, runnable prototype with an end-to-end journey: confused user -> guided intake -> AI interpretation -> deterministic reasoning -> cautious result -> confidence breakdown -> verification roadmap -> human handoff. Responsible AI is visible inside the app, not just in a README: a guardrail with passing tests, a confidence breakdown, an "evidence for judges" panel showing exactly which rule fired and what the app refused to decide, and privacy-by-design intake. The user leaves with something usable - a checklist and script they can take to a caseworker.

What we learned

That in high-stakes civic systems, restraint is the feature. The most valuable thing an AI can do here is reduce false certainty: simplify the language, show its reasoning, surface what's missing, and then deliberately hand the final decision to a human and an official source. We learned to separate the deterministic, auditable part (thresholds and labels) from the interpretive part (messy language and explanation), and to make uncertainty a first-class, visible output.

What's next for CarePath Navigator

Replacing synthetic thresholds with real, state-specific rules verified against official sources; adding more programs (SNAP, WIC) using the same hybrid pattern; multilingual plain-language explanations; accessibility hardening; and partnering with community health centers or 211 navigators so the human handoff connects to a real person.

Built With

• anthropic-api
• css
• deterministic-rules-engine
• html
• javascript
• natural-language-processing
• node-test
• node.js
• react
• tailwindcss
• typescript
• vite
• vitest