Tony Morinello

All work

Practical AI · Communication

LiveKitSellerLab

A hands-on lab where new sellers hear why real-time voice AI is hard, then practice a discovery call scored by an AI judge.

Role
Sole designer and developer
Built with
Python, LiveKit Agents, LiveKit Cloud, Next.js, React, TypeScript, Cloudflare Workers, Deepgram, ai-coustics

Visit the site View the source

Walkthrough: LiveKit Seller Lab, silent, 5 steps
The lab's overview playing Experiment 1's Baseline call: a timeline of the test caller's three phrases, the Baseline agent cut off twice and the Enhanced agent answering once.

LiveKit Seller Lab teaches people who sell voice AI why it’s hard to build. Juniper, a voice agent that answers the phone for a made-up restaurant, takes the same recorded caller twice in each experiment, with one setting changed. The learner predicts what will happen, hears the difference, then tries it with their own voice. It’s an independent, open-source project, not affiliated with LiveKit, and it runs on free plans.

The problem

Customers describe a voice agent by how a call felt. It keeps cutting people off. It stops talking whenever I say “uh-huh.” It answered someone at the next table. It takes too long to answer. A seller has to work out what’s behind each complaint and ask the question that gets at it. Those problems are easier to hear than to explain, so the lab plays them.

What I built

The lab has four experiments, one problem each. Turn detection sets a silence timer against LiveKit’s turn detector, which listens to what the caller says and how they say it. Interruptions sets “any half second of speech stops the agent” against adaptive interruption handling. The coffee shop books a table from a busy café, with and without ai-coustics voice isolation. The pause sets a quick model against one that reasons before it answers.

Each experiment runs in four steps. The learner locks in a prediction, then runs the test caller on both settings, and the page draws both runs on one timeline: the caller’s words, when Juniper was thinking or speaking, and where it was cut off. Next they try it with their own voice. A card closes the experiment with what a customer says, what’s actually happening, what LiveKit does about it, and the question to ask. Each card links the LiveKit pages its facts came from and says when they were read.

Before the experiments, “Make it your own” has the learner rename the restaurant and give Juniper one house rule. An agent’s behavior starts as plain written instructions, and this is the quickest way to see it.

After them comes a practice call with Priya, an AI prospect: the CTO of Fluento, a 12-person startup whose language-learning app includes a voice tutor. She shares what she knows only when asked good questions, and asks two technical questions of her own. When the learner ends the call, a judge scores it on six items, and a coach with a different voice talks them through the score. For a facilitator, a pilot mode adds a five-question check before and after the lab, with consent first, and a page of results.

Key decisions

Same caller, two settings

A learner’s own voice changes from one try to the next, so comparing settings by voice proves little. Each experiment plays a recorded test caller into the call instead. The clips go into the same microphone track the learner’s voice uses, through a Web Audio mixer, so the agent hears exactly the same audio on both settings.

The clips took tuning. When I made them, Juniper started answering about 1.2 seconds after the caller stopped, and a wrong decision can only be heard when the pause is longer than the agent’s response time, so the turn-detection clip pauses for 1.8 seconds. Most natural “uh-huh”s came out shorter than half a second, too short to stop even the baseline, so the script that makes that clip keeps trying until a take lasts between 0.5 and 0.8 seconds.

Settings change mid-call

The learner flips a setting during a call, and the agent changes without reconnecting. Turn detection and the model change on the running session. Interruption settings are fixed when an agent is created, so that switch hands the call to a fresh Juniper that keeps the conversation so far.

One worker plays every voice

Juniper, Priya and the coach all run in one Python worker on LiveKit Cloud. When the practice page asks for a room, the request says so in the agent’s dispatch, and the worker runs Priya instead of Juniper. Ending the call hands off to the coach.

The judge has to show its work

An LLM judges the practice call, and code checks the judge. A point needs a quote that’s really in the call, matched word for word, and the quote’s time comes from the transcript, not from the model. A made-up technical answer counts only if the seller said it. It zeroes technical honesty and fails the call, whatever the total. Ten tests cover those rules.

A public demo that stays cheap

Live calls need an access code. The lab gives out at most 40 rooms a day, each join token lasts two minutes, and the agent ends a lab session after 40 minutes and a practice call after 15. Without a code the lab still works: both settings of every experiment were recorded from real calls, so anyone can make a prediction, play the two runs and get the card. The pages are static files. The only server code is a small Cloudflare Worker that checks the code and hands out tokens, and it never calls LiveKit’s API, because the agent’s dispatch rides inside the join token.

A closer look

The overview replays a recorded call from Experiment 1. The baseline jumps in at each pause and is cut off twice. The turn detector waits for “Friday at seven” and answers once.

In the lab, the learner predicts what the baseline will do with “I’d like a table for… four people on… Friday at seven,” then opens both recorded runs. The timeline and the transcripts show what Juniper had heard each time it answered.

The card for Experiment 1 starts with what a customer says, “It keeps cutting people off,” and ends with the question to ask: what do your callers have to say that takes a while, like account numbers, addresses or medication names?

The practice page shows who the learner is calling, and how the call is scored, before it starts.

How it’s built draws the path of a call, from the browser through the Worker and LiveKit Cloud’s room to the agent worker and its models.

How I checked it

I ran each experiment’s test caller twice on each setting on LiveKit Cloud, and each setting did the same thing every time. With a silence timer, Juniper answered at each pause; with the turn detector, it answered once. Every baseline run in the coffee shop took 11 or 12 words from the next table as the caller’s and answered them, and with voice isolation Juniper heard only the caller. Krisp VIVA, which I also tried, let the next table through. The quick model answered in 0.54 to 0.69 seconds and the reasoning model in 1.77 to 2.23.

For the judge, I scored two saved practice calls twice each. The honest call passed with 12 of 12 both times. The bluffing call promised the tutor would “never interrupt a learner again, guaranteed.” It scored 5 and then 4 of 12, and the judge quoted the guarantee both times. The same test moved the judge to a smaller model that gave the same verdicts for about a tenth of the cost.

The repo has 87 tests for the pages and the API and 16 for the agent, and GitHub runs them on every push. None of them needs keys or places a call.