Tessera

Inspiration

Healthcare is being automated from both sides — except the patient's. Providers are deploying voice agents to chase claims and recover revenue; payers are deploying them to explain denials and collect payment. Sit in on a billing call today and there's an AI working for the hospital and, increasingly, one working for the insurer. The patient is the only party on the line without an agent — and they're the one with the least power and the most at stake. Tessera fills that empty seat.

What it does

Tessera is a patient-side voice advocate. Given a denied insurance claim, it places the call, states the patient's case, and argues it in real time against the insurer — citing the patient's own records to push back when the denial doesn't hold up. Crucially, it knows the limits of its authority: when the call reaches a genuine tradeoff that belongs to the patient — accept a fast partial payment, or file a formal appeal for the full amount and wait weeks — it pauses and hands that decision back to the person. It acts on their choice, then returns a structured outcome: what was resolved, what's pending, and when it will follow up. The agent fights the bureaucracy; the patient keeps the decisions that are theirs.

How we built it

The core is two sealed Grok voice sessions on a server-side orchestrator. One is Tessera — the patient's advocate, carrying a patient dossier and a goal, with function tools to request a patient decision and to close out the call with a structured result. The other is a simulated insurer with a hidden persona and a realistic obstacle arc. The two sessions share no state; the orchestrator owns turn-taking, relaying audio between them only on turn completion. That separation is the whole point: Tessera's responses are generated live, reacting to an adversary it cannot see. A Next.js front end on Vercel renders the live transcript, plays Tessera's voice, surfaces the handoff decision, and shows the final outcome card.

Challenges we ran into

The hardest problem wasn't the AI — it was turn-taking. Two live voice agents with automatic voice detection talk over each other, trigger on their own output, and hang. We solved it by taking voice-activity detection off both sessions entirely and making a server-side orchestrator the sole authority on who speaks when. The second challenge was honesty: you can't call a real insurer with synthetic patient data, so the insurer had to be simulated — but the insurer is not fully scripted rather it's a grok voice agent with a given set of instructions where it tries to challenge Tessera and only gives up after Tessera has tried really hard. The third was time: as a solo build, every minute on polish was a minute not spent hardening the call loop, which forced ruthless prioritization.

Accomplishments that we're proud of

The handoff. It would have been easy to build an agent that just "wins" and impresses a room — but that's not autonomy, it's a better-served patient. Tessera surfaces a buried prior authorization, fights to the real wall on an unauthorized add-on, and then stops and gives the genuine tradeoff back to the patient. That single beat — the agent knowing what isn't its decision to make — is the thing I'm proudest of, because it's the difference between automating service and restoring agency. We're also proud that the demo is honest: Tessera doesn't magically overturn the denial; it does the real work and names its limits.

What we learned

That the interesting question in agentic healthcare isn't "can the agent do the task" — it's "whose side is the agent on." The capability to navigate a phone call is increasingly commodity; the alignment is not. We also learned, concretely, that reliable multi-agent voice is an orchestration problem before it's a model problem — the model was never the bottleneck. And we learned that an agent restrained by design — one that hands decisions back rather than seizing them — is more compelling than an all-powerful one, not less.

What's next for Tessera

Real telephony, so Tessera can place actual calls rather than argue against a simulated insurer. Connection to a patient's real claims and records so reconciliation runs against ground truth, not a dossier we supply. Expansion beyond denied claims to the other calls patients dread — prior-auth limbo, surprise bills, referral chases. And an interpreter mode, because the patients with the emptiest seat of all are the ones who can't argue in the language the system speaks. The throughline stays the same: an agent whose only loyalty is to the patient.

Built With

• cursor
• grok
• node.js
• vercel