ActionBride Dental

Inspiration

Maya's dentist hands her a printout: two fillings and a crown, $1,500. She has dental insurance through work, but the paper can't answer the question she actually has: what will I pay?

The answer is hidden in a benefits summary written in insurance language: deductibles, coinsurance, allowed amounts, an annual maximum that resets every benefit year. Most people never work it out. They overpay, they put off care, or they let benefits expire unused.

Then we thought about who has it hardest. Someone who is blind can't read the printout. Someone who finds reading difficult gives up on the second page. Someone who can't use their hands can't type into a form. Understanding your own care shouldn't depend on reading small print.

So we built ActionBridge Dental: an agentic, voice-first benefits assistant that anyone can talk to.

What it does

Speak, upload or snap a photo. ActionBridge reads your dentist's estimate and your plan summary, even multi-page PDFs, and turns them into one clear answer:

It reads, then proves it. Every fact it finds is shown on an "Is this right?" card, with the exact words from your document. Nothing is used until you say yes.
It asks only what matters. An adaptive planner asks just the questions that change your cost, at most four at a time, and turns "I don't know" into a question to take to your dentist or insurer.
It counts, and it never guesses. A deterministic benefits engine (not the AI) calculates every dollar, in integer cents.
It finds the better timing. If your dentist allows a window, it compares doing the treatment now with doing it after your benefits reset. Maya pays \$1,200 doing everything now, or \$725 with the crown in January, still inside her dentist's window. Same care, \$475 less.
It talks to you, and listens. Turn on voice and it reads every step aloud in a natural voice (Amazon Polly). On the web you can answer every step out loud: "yes", "not right", "in network", "about two hundred fifty dollars", "continue". It confirms what it heard and moves on by itself. No typing, no clicking.
It helps you act. It shows your benefits left this year, gives you a ready-made question for your dentist, compares the cost of paying cash, and adds a reminder to Google Calendar (or your phone) before your benefits reset.

How we built it

The core idea: AI reads. The calculator counts. You confirm.

Speak / upload / photo
        │
  Transcribe · Textract ──► Bedrock agent (bounded tool loop)
        │                      record_case_facts → check_missing_facts
        ▼
  "Is this right?" cards ──► adaptive questions ──► deterministic engine
        │                                                │
   Polly reads it aloud ◄──────── plain-language result ◄┘

Agent: Amazon Bedrock (Nova 2 Lite) with typed tool use in a bounded loop (a limit on tool calls and turns). The model proposes facts; the server checks each quote word for word against the source and drops any number that isn't in its quote.
Engine: a pure TypeScript package with no I/O, no clock and no randomness, enforced by tests. It calculates per benefit year, applies the deductible, coinsurance and annual maximum, and searches only dates inside the window your dentist allows.
Documents and voice: Amazon Textract (instant, plus asynchronous for multi-page PDFs), Amazon Transcribe (phone and browser audio), Amazon Polly (neural voice), and the browser's speech recognition for live hands-free answers.
Backend: API Gateway (JWT auth, CORS) → Lambda → DynamoDB, with SQS and a dead-letter queue driving a background worker with leases and retries. Uploads go straight to a private, encrypted S3 bucket through short-lived presigned forms and are deleted after reading. Sign-in uses Amazon Cognito. All of it is infrastructure as code (AWS SAM / CloudFormation), monitored in CloudWatch, with least-privilege IAM per function: 12 AWS services, each with one clear job.
Apps: an Expo (React Native) app for iOS and Android, and a React web app on Vercel, both on the same API, sharing Zod contracts so the client can never send or invent an amount.

The math behind Maya's \$475

Maya's plan pays 80% for fillings and 50% for crowns after a \$50 deductible. The yearly maximum is \$800 and \$500 is already used, so the insurer can pay at most \$300 more this year.

For each benefit year $y$, the plan pays its share up to whatever is left of the yearly maximum:

$$\text{PlanPays}y = \min\Big(M_y - U_y,\ \sum{i \in y} r_i \,(a_i - d_i)\Big)$$

where $M_y$ is the annual maximum, $U_y$ what the plan already paid this year, $r_i$ the coverage rate, $a_i$ the allowed amount and $d_i$ the deductible applied to procedure $i$.

Everything in 2026: the plan's share would be $160 + 200 + 500 = 860$, but only \$300 is left:

$$\text{You pay} = 1500 - \min(300,\ 860) = \$1{,}200$$

Crown in January 2027 (new year, new maximum, new deductible):

$$\underbrace{500 - \min(300,\ 360)}{2026:\ \$200} \;+\; \underbrace{1000 - 0.5\,(1000 - 50)}{2027:\ \$525} = \$725$$

The engine works in integer cents and basis points (8000 = 80%), so the numbers never drift.

Challenges we ran into

Making an AI that can't make up numbers. Language models are confident. We made the model prove every fact with an exact quote, verified those quotes on the server, and kept all arithmetic out of the model entirely.
The agent forgetting what it had already read. In live testing, the agent sometimes recorded everything, then made a second tool call to add one detail, and that call erased the rest. We found it by replaying real runs from the database, made facts merge across calls, and added a regression test built from the exact failure.
Insurance language is tricky. The model once read "The annual maximum applies to basic and major services" as a plan restriction, which blocked the estimate. We now read that sentence directly from the text in code, and added guards so a yearly maximum or deductible can never be mistaken for a limit.
Real-world infrastructure. Neural Polly voices aren't offered in our home region (us-east-2), so speech runs in us-east-1. Multi-page PDFs needed asynchronous Textract within a strict time budget. A validation error once made the web app retry thousands of times, until we taught the server to refuse contradictory answers and the client to explain them.
Hands-free without chaos. A voice loop has to know when to talk, when to listen, and what a fuzzy reply means. We used fixed rules for understanding spoken answers (not the AI), always show "I heard: …", and keep a tap fallback on every step.

Accomplishments that we're proud of

A fully hands-free run from documents to result on the web, covered by an automated browser test.
300 unit and integration tests, 12 browser tests with accessibility (axe) checks from 360 to 1440 px, and a 5/5 agent evaluation on Bedrock (complete, missing data, contradictory amounts, an unsupported plan rule, and prompt injection).
Live on AWS today, with real sign-in and saved plans that survive a reload.
A design where the AI is genuinely useful but never in charge of the money.

What we learned

Trust is a design problem, not a model problem. Quotes, confirmation and a deterministic engine did more for reliability than any prompt.
Test the agent like a system. Our worst bugs only appeared in live runs, so we learned to log, replay and turn each failure into a test.
Accessibility makes things better for everyone. Voice guidance, one question at a time and plain-language results help a busy parent as much as a screen-reader user.

What's next for ActionBridge Dental

Testing with blind and low-vision users, and with people with limited hand use. We built for them; now we need to learn from them.
Hands-free answers on the phone app (today the phone reads aloud and you tap).
Waiting periods, exclusions and frequency limits estimated rather than just flagged.
More languages, and connecting to insurer data with the employee's consent.

Try it: action-bridge-dental-web.vercel.app. Test login: [email protected] / DentalDemo2026! (fictional sample data only). Turn on Voice in the top bar and upload the two sample PDFs from docs/demo.

Estimates only: your dentist decides timing and your insurer decides final payment.