CashNow Voice Lab

Setup

idle

Engine

Audio source

Use headphones so the agent doesn't hear itself. Your browser will ask for the microphone.

Mode

Customer — the data preloaded for this call

Name to greet (optional)

Voice

Language LLM

Advanced settings

Speech Engine · turn eagerness

Speech Engine · speculative turn (LLM starts before turn is certain) ElevenLabs Agent · model (ElevenLabs runs it, outside the UAE) Speech Engine · background voice filter (TV, people nearby don't count as the caller) Speech Engine · “mm-hmm”, “okay”, “yeah” don't interrupt the agent LLM hedging — send each turn twice, use the faster (cuts slow turns; 2× LLM requests · Speech Engine + DIY) Voice speed: 0.92× ElevenLabs APIs · VAD silence before end of turn: 0.4s Pipecat · VAD stop seconds: 0.2s Pipecat · Smart Turn model Filler line while tools run (“One moment please…”)

Live conversation

Start a call — the two-party transcript, tool calls and interruptions appear here live.

Latency

per turn · caller stops → agent audio

—

time to first word

—

voice-to-voice p50

—

last turn

turns

tool calls

—

barge-in stop

hear (end-of-turn + STT)think (LLM)toolsspeak (TTS → first audio)T3* = caller talked over the agent · T3† = agent re-engaged after silence (not counted)

Event log show VAD/partials

Your calls

phone and browser calls, newest first · click a call for its transcript and timings

When	Number	Engine · model	Length	Greeting	First reply	Typical reply	Slowest	Replies	Talk-overs	How it ended

Launch concurrent calls

Default engine for new calls Real phone calls (test line) — one row per call

Type any number (971…). New numbers are added to the lab's allowlist when you press Start. Each call needs its own phone with someone answering. Mode B = the agent looks things up with live tool calls during the call.

+ Synthetic callers (scripted, no phone needed)

Their mode

Their customer

LLM (all calls)

Browser-mic calls stay on the Live call tab (one mic per page). Everything here runs at the same time — the summary shows how latency holds up while they all talk.

live now

calls

—

V2V p50

—

V2V avg

—

V2V max

tool calls

errors

Pick phone numbers and/or synthetic callers, then Start all.

Run a comparison

scripted synthetic callers · same script, same LLM, same tools

Engines

Script

Mode

Customer

Voice

LLM

Runs per engine

Concurrent calls

Load test = raise Concurrent calls. ElevenLabs trial concurrency is limited, so start small (1 → 3 → 5). Each synthetic call uses real ElevenLabs + LLM minutes.

Past comparisons

When	Engines	Script	Runs×Conc	Status

Results

hear = caller stops → transcript ready (turn detection + STT) · think = → LLM first token (incl. tools) · speak = → first agent audio. All measured at the same point on our side for every engine.

Tools the agent can call

shared by all three engines

On	Name	Type	Kind	Delay	Fail%

Mode A offers only action + system tools (data is preloaded). Mode B and Hybrid offer everything. Add a delay to see how each engine handles slow lookups, or a fail % to test error handling.

Edit tool

Pick a tool on the left.

Synthetic customers

fictional — no real customer data in the lab

Id	Name	Lang	Owes (AED)	Overdue	Scenario

Customer record (what Mode A preloads / what tools return)

Agent prompt

used by all engines

Agent name

First message (spoken on answer) — {{agent_name}}, {{first_name}}

Filler while tools run

Goodbye (when only end_call)

System prompt — {{agent_name}} {{today}} {{language}} {{mode_rules}} {{customer_block}}

Voices

ElevenLabs EU workspace

Preview text

Synthetic caller scripts

Each turn: {"say": "...", "bargeInAfterMs": 1400} — bargeInAfterMs makes the caller talk over the agent's previous answer. The caller voice is "Aryan" (Indian male).

Phone allowlist (test numbers)

One number per line, digits only. The lab refuses to dial anything else.

Calls

When	Engine	Source	Mode	Customer	Dur	Turns	V2V p50	V2V avg	1st word	Tools	Barge	End

System status

How it's wired

Speech Engine — our bridge streams caller audio (PCM 16 kHz) to ElevenLabs' conversation WebSocket (EU). ElevenLabs does speech-to-text, turn detection and interruptions, then connects back to this lab's brain (/se/ws) with the transcript; the brain calls the LLM + tools and streams text back; ElevenLabs speaks it.

ElevenLabs APIs (DIY) — our bridge runs the loop itself: Scribe v2 Realtime (its VAD ends the turn) → the same brain → Flash TTS over the multi-context WebSocket. Barge-in = partial transcript while the agent speaks.

Pipecat — a Python pipeline on this server: Silero VAD + Smart Turn decide the turn, ElevenLabs realtime STT/TTS, the same LLM; tools call back into the same tool runner.

Phone — the VoiceGateway test line (not the prod line). Its allowlist admits the office network, so the lab reaches it through a relay on the Mac; if that relay is down, phone calls fail (browser + synthetic still work).

Latency is measured identically for every engine at our side: the moment the caller's audio stops → the first audible agent audio we receive. The phone network's own delay is the same for all engines and not included.