Handoff Brain

When a teammate leaves, their promises to customers are buried in call transcripts. Handoff Brain reads every call, tells you what to do first, and keeps every promise, with receipts.

Comment 8

Inspiration

I'm an onboarding consultant. Every day I make promises to customers on calls: "I'll check with the carrier," "I'll call your IT person," "I'll get back to you by Friday."

Every account I take over from a teammate comes with the same problem: the truth about where that customer stands is buried in hours of call transcripts and CRM notes. Sometimes there's no summary at all, or the notes get written up hours after the call. A former colleague told me it takes 15+ minutes of reading per account just to figure out what's going on, and the most dangerous things are the easiest to miss: a promise we made on a call and never followed up on, or a customer who quietly said they're about to cancel.

Customers rarely leave because of the product. They leave because "nobody ever got back to me." A company brain should know the state of every customer and every promise we made, not just answer questions about documents. So I built the brain for the moment an account changes hands.

What it does

Handoff Brain turns a departing teammate's accounts into a plan the next person can act on Monday morning.

  • Read everything in 60 seconds: it reads every call transcript for every inherited account and marks each one red, amber or green with a one-sentence reason.
  • Start here: the landing page for the new owner: first moves across every account, most urgent first, with the reason for each.
  • Handoff cards: the onboarding journey (Kickoff → Data sync → Texting registration → Number port → Phone install → Training → Check-ins), risks, promises, the next call plan, and a CRM-ready note. The account record (address, main line, primary contact) sits next to what was actually said on calls.
  • ✓ Verified receipts: every quote is checked word for word against the real transcript. If it isn't there, it doesn't get the badge.
  • Ask anything, two modes: history questions are answered only from the record and calls, with the quote. "What should I do?" questions get the brain's own recommendations, clearly labeled as advice, not fact.
  • Promise Radar: promises we broke, promises we owe, what customers owe us, and what we kept. "Keep the promise" drafts the follow-up in one click.
  • Real phone exit call: before the teammate leaves, a Guava voice agent phones them on a real line and asks what their notes are missing. The answers flow straight back into the brain.
  • Hands-free call ingestion: new transcripts land in an inbox that Triggerware watches; accounts update on their own, with no pasting.
  • Product Insights: patterns across every call, in customers' own words, for product managers.
  • Brief me in 60 seconds: an ElevenLabs voice briefing for each account.

Our demo follows Maya, a consultant leaving on Friday, and Sam, who inherits her five clinics. Maya is just the example: the same flow works for CSMs, account managers, sales reps and support leads, anyone who inherits customers.

How I built it

  • AppStarter generated the build spec and acceptance criteria.
  • Triggerware: a local Triggerware server with Lua tables over the brain's live data (accounts, promises, tickets, call inbox) and standing SQL triggers (hb_new_calls, hb_at_risk_accounts, hb_open_promises) whose deltas stream into the app through the Python SDK.
  • Guava: the Python SDK places the outbound exit call. Each answer is written as a new transcript into the inbox, so the loop is call → transcript → Triggerware → updated handoff.
  • AI: a provider-agnostic, OpenAI-compatible layer (Gemini, Groq, or Claude) reads transcripts and returns a structured handoff card as JSON. If a model is retired, the server finds an available one by itself.
  • Voice: ElevenLabs text-to-speech for briefings.
  • App: a plain HTML/JS front end and a zero-dependency Python server that keeps every API key off the browser.
  • Every AI feature falls back to a prepared summary, so the demo keeps working if a model is overloaded.

Challenges

  • I started with a "who knows what" knowledge graph in 3D. It looked impressive and explained nothing, so I threw it out and rebuilt around one concrete workflow.
  • Getting real data flowing on a venue network: certificate issues, retired model names, rate limits. I hit Gemini's free quota live and moved to Groq in minutes thanks to the provider layer.
  • Twilio needed a paid number for real calls, so I switched to Guava's developer tier.
  • Learning Triggerware's table format (Lua generators, string column types, comma-separated joins, 6-field cron) on the fly.
  • Keeping it honest: the AI must quote the transcript, never invent facts, and keep its own advice clearly separate from what the customer said.

What I learned

The best "company brain" isn't the one that knows the most; it's the one that shows up at the moment knowledge is about to be lost. Trust is the product: receipts and labeled advice matter more than clever summaries. And a clear story beats a flashy visualization.

Note on data

All demo accounts are fictionalized versions of real onboarding calls. Every clinic, person, address, phone number and email has been changed, and the vendor is a made-up company called "Northwind." Account records are demo data, not a live CRM connection.

What's next

Live Salesforce sync (read the account record, write the activity note back), call ingestion from Gong, Zoom and Meet, exit calls scheduled automatically when someone's last day is set, Slack reminders before a promise slips, and handoffs beyond departures: role changes, leave coverage and territory moves.

Video link

https://www.loom.com/share/b8d82e5ef94e4ecf8c74abc3c63ef865

Built With

+ 16 more
Share this project:

Updates

Submission history