Voice agent demora 5 seg (customer já desistiu)

Voice agent demora 5 seg (customer já desistiu)

What just happened (October 2026):

Amazon published research on voice agent latency:

"Customer asks voice agent (WhatsApp, Telegram, phone)."

"Agent generates text response (600ms, super fast)."

"Agent starts TTS (text-to-speech conversion)."

"Problem: TTS buffers entire response before speaking."

"Result: 5+ seconds of silence while customer waits."

"Customer perception: Agent is broken/slow."

"Solution: Stream TTS output (Kokoro model on SageMaker)."

"Outcome: Speech starts in 200ms (feels instant)."

What this means for your company:

Current situation (your voice agent on WhatsApp):

Customer: "Qual é meu saldo?" Agent (backend): Step 1: Parse query (50ms) ✓ FAST Step 2: Look up saldo (100ms) ✓ FAST Step 3: Generate text: "Seu saldo é R$1.234,56" (200ms) ✓ FAST Step 4: Convert text → speech (TTS) (4,500ms) ✗ SLOW (Agent waits for full audio before sending) Total: 4,850ms = 4.8 SECONDS

What customer experiences: [Customer asks question] [Silence... 1 sec] [Silence... 2 sec] [Silence... 3 sec] [Silence... 4 sec] [Agent finally speaks] [Customer already moved on / closed app]

Customer perception: "This agent is slow" "Doesn't work" "I'll call human support instead"

Reality: Agent was FAST (steps 1-3 = 350ms) TTS was SLOW (step 4 = 4,500ms) Customer blamed agent (didn't blame TTS) You lose customer (for wrong reason)

With Kokoro streaming (Amazon solution): Customer: "Qual é meu saldo?" Agent (backend): Step 1: Parse query (50ms) ✓ FAST Step 2: Look up saldo (100ms) ✓ FAST Step 3: Generate text: "Seu saldo é R$1.234,56" (200ms) ✓ FAST Step 4a: Start TTS stream (200ms) ✓ INSTANT Step 4b: Stream audio as it generates (2,000ms) ✓ STREAMING Total perceived latency: 200ms (FEELS INSTANT)

What customer experiences: [Customer asks question] [Agent speaks almost immediately (200ms)] [Audio streams naturally] [Customer satisfied]

Customer perception: "Wow, this agent is fast!" "Feels like talking to human" "I'll use this for everything"

Reality: Same agent, same speed (350ms to answer) Better TTS (streaming vs buffering) Customer happy (for right reason) You keep customer (better UX)

---

The hidden cost of TTS latency

Why your voice agent feels slow (even if it's not)

The psychology of waiting (invisible to you, critical to customer):

Human expectations for voice: Phone: Answer expected in <1 sec ("Is anyone there?") Human agent: Response expected in <2 sec (natural conversation) AI agent: Expectation same as human (~2 sec)

Your current voice agent: Response time: 4.8 sec (4x slower than expectation) Customer feeling: "Something's wrong" Dropout rate: 30-40% (customer hangs up before agent speaks)

With Kokoro streaming: Response time: 0.2 sec (feels instant) Customer feeling: "This is responsive" Dropout rate: <5% (customer waits, hears agent immediately)

Business impact: Current: 100 calls → 30-40 complete → 60-70 abandoned Kokoro: 100 calls → 95 complete → 5 abandoned Improvement: 60-70% increase in agent usage

Why TTS buffering happens (technical root cause):

Old approach (buffer entire response):

1. LLM generates full text
2. Wait for text to complete
3. Send text to TTS
4. Wait for TTS to generate full audio
5. Send audio to customer

Timeline: 0ms: Start 350ms: Text ready ("Seu saldo é R$1.234,56") 4,850ms: Audio ready (entire sentence as MP3/WAV) 4,850ms: Send to customer Customer hears: Silence for 4.8 seconds, then voice

New approach (stream as you generate):

1. LLM starts generating text
2. Text arrives token-by-token ("Seu" → "saldo" → "é")
3. Send tokens to TTS immediately (don't wait for full text)
4. TTS starts converting tokens to speech immediately
5. Stream audio chunks as they arrive
6. Customer hears speech while text is still generating

Timeline: 0ms: Start 200ms: First audio chunk ready ("Seu") → SEND 250ms: Second chunk ready ("saldo") → SEND 300ms: Third chunk ready ("é") → SEND ... 2,200ms: Last chunk ready ("56") → SEND Customer hears: Speech starts at 200ms, flows naturally

---

Real-world impact: Why latency kills adoption

The invisible force destroying your voice agent

Scenario 1: Customer service (WhatsApp voice agent)

Current (with buffering): Customer: "Preciso resolver meu problema de cobrança" Agent: [Thinking 350ms] Agent: [Waiting for TTS 4,500ms] [Total: 4.85 sec silence] Customer: "Hello? Is anyone there?" Customer: [Hangs up] [Tries calling human support] Agent never got chance to help Result: Agent failure (actually customer impatience)

With Kokoro streaming: Customer: "Preciso resolver meu problema de cobrança" Agent: [Thinking 350ms] Agent: [Speaking after 200ms] "Entendo seu problema. Vou checar sua conta agora..." [streams naturally] Customer: [Listens, feels helped] [Agent resolves issue] Result: Agent success (customer stays engaged)

Scenario 2: Sales automation (phone agent)

Current (with buffering): Prospect: "What's your pricing?" Agent: [Thinking 350ms] Agent: [Waiting for TTS 4,500ms] [4.85 sec silence] Prospect: "This is awkward. Let me email your sales team." [Hangs up, never heard agent's pitch] Agent lost deal (actually lost prospect in first 5 seconds)

With Kokoro streaming: Prospect: "What's your pricing?" Agent: [Thinking 350ms] Agent: [Speaking after 200ms] "Great question! We have three plans starting at $99/month..." Prospect: [Engaged, listening] [Agent delivers full pitch] Result: Agent wins deal (customer heard value)

Scenario 3: Multilingual agent (Spanish, Portuguese, etc)

Current (with buffering): Customer (Spanish): "¿Cuál es el estado de mi pedido?" Agent: [Thinking + generating response in Spanish: 350ms] Agent: [Waiting for Spanish TTS: 4,500ms] [4.85 sec silence] Customer: [Switched to English to try English agent] [Language switch = conversation lost] Agent never served customer in their language

With Kokoro streaming: Customer (Spanish): "¿Cuál es el estado de mi pedido?" Agent: [Thinking + streaming Spanish: 200ms start] Agent: [Speaking naturally in Spanish] Customer: [Satisfied, agent understood their language] Result: Agent builds trust (language fluency + speed)

---

Kokoro TTS: Why streaming changes everything

The technical advantage (simplified)

Key insight: Stream tokens, not sentences

Old TTS (wait for full sentence): Input: "Seu saldo é R$1.234,56" (1 sentence, 6 tokens) Process: Wait for all 6 tokens Output: Generate full audio (4.5 seconds) Result: Customer waits 4.5 seconds

Kokoro streaming (stream tokens as they arrive): Input token 1: "Seu" → TTS starts immediately Input token 2: "saldo" → TTS streams (doesn't wait) Input token 3: "é" → TTS streams Input token 4: "R$" → TTS streams ... Output: First audio arrives in 200ms (customer hears "Seu") Rest streams naturally (customer hears full sentence in 2 sec) Result: Customer hears speech at 200ms (feels instant)

Practical numbers (Kokoro on SageMaker):

Short response (< 20 words): Old TTS: 1.5-2 sec latency (buffer entire phrase) Kokoro: 200ms latency (stream starts immediately) Improvement: 7-10x faster

Medium response (20-50 words): Old TTS: 3-4 sec latency Kokoro: 200ms latency (speech starts, streams over 2 sec) Improvement: 15-20x faster perceived

Long response (50+ words): Old TTS: 5-8 sec latency Kokoro: 200ms latency (speech starts, streams over 5+ sec) Improvement: 25-40x faster perceived

Key: Customer hears "I'm responding" at 200ms vs silent 5+ seconds (feels broken)

---

How to implement Kokoro streaming (practical guide)

Architecture change (simpler than you think)

Current architecture (buffering):

┌─────────────┐ │ Customer │ │ (WhatsApp) │ └──────┬──────┘ │ ↓ ┌─────────────┐ │ Agent │ Step 1: Parse query (50ms) │ (LLM) │ Step 2: Generate response (200ms) └──────┬──────┘ │ "Seu saldo é R$1.234,56" ↓ ┌─────────────┐ │ TTS │ Step 3: Wait for full text ✗ (bottleneck) │ (Buffer) │ Step 4: Convert to audio (4.5 sec) └──────┬──────┘ │ MP3 audio ↓ ┌─────────────┐ │ Send to │ Step 5: Customer hears after 4.8 sec ✗ │ Customer │ └─────────────┘

Problem: Customer waits 4.8 seconds for ANY sound

New architecture (streaming):

┌─────────────┐ │ Customer │ │ (WhatsApp) │ └──────┬──────┘ │ ↓ ┌─────────────┐ │ Agent │ Step 1: Parse query (50ms) │ (LLM) │ Step 2: Generate response tokens (on-the-fly) │ (Streaming)│ └──────┬──────┘ │ "Seu" → "saldo" → "é" → "R$" (streaming) ↓ ┌─────────────┐ │ TTS │ Step 3: Stream tokens to TTS (don't wait) │ (Kokoro) │ Step 4: Generate audio chunks immediately │ (Streaming) │ └──────┬──────┘ │ Chunk 1: "Seu" (200ms) → SEND │ Chunk 2: "saldo" (250ms) → SEND │ Chunk 3: "é R$" (300ms) → SEND ↓ (continues streaming) ┌─────────────┐ │ Send to │ Step 5: Customer hears at 200ms ✓ │ Customer │ (continues streaming naturally) │ (stream) │ └─────────────┘

Benefit: Customer hears response at 200ms (feels instant)

Code example (pseudocode):

python

Old approach (buffering - DON'T DO THIS)

def agent_response_old(query): response_text = llm.generate(query) # 200ms audio = tts.convert(response_text) # 4,500ms (blocks) send_to_customer(audio) # Customer hears at 4,700ms

New approach (streaming - DO THIS)

def agent_response_new(query): # Stream response tokens token_stream = llm.generate_stream(query)

# Create TTS stream
audio_stream = tts.stream()  # Kokoro on SageMaker

# Send tokens to TTS immediately (don't wait)
for token in token_stream:
    audio_stream.add_token(token)
    # Kokoro generates audio for this token
    # Customer hears it within 200ms

# Audio streams to customer while LLM still generating
# Result: First audio at 200ms, natural flow

Implementation effort: 2-3 days (if using SageMaker)

---

Measuring impact: Before vs after Kokoro

Metrics that matter

Latency metrics:

                Before Kokoro    After Kokoro    Improvement

Time to first audio: 4,800ms 200ms 24x faster Total response time: 5,500ms 2,200ms 2.5x faster Customer perception: "Agent is slow" "Agent is quick" Game-changer

Business metrics:

                Before Kokoro    After Kokoro    Improvement

Call completion: 60% 95% +60% more calls Avg call duration: 120 sec 95 sec -21% shorter Customer satisfaction: 6.2/10 9.1/10 +47% CSAT Agent abandonment: 40% 5% -88% less Conversion rate: 12% 28% +133% revenue

Cost metrics:

Current (buffering): 100 calls/day 40 abandoned (no ROI) 60 completed ROI: 60%

With Kokoro streaming: 100 calls/day 5 abandoned (much better) 95 completed ROI: 95% (+58% improvement)

Annual impact: 100 calls/day × 250 working days = 25,000 calls/year Extra completed: 7,500 calls/year × (assuming R$50 value) = R$375k/year Kokoro cost: ~R$50k/year (SageMaker + infrastructure) Net ROI: R$325k/year profit

---

Implementation roadmap (how to get there)

Step 1: Audit current TTS latency (week 1)

[ ] Measure current TTS latency (should be 3-5 sec) [ ] Log time from LLM output → Audio received [ ] Identify where delay happens (almost always TTS buffering) [ ] Calculate customer impact (abandonment rate × value)

Step 2: Choose streaming TTS (week 2)

Options: [ ] Amazon Kokoro (on SageMaker) - Recommended for AWS [ ] Google Cloud Text-to-Speech Premium (streaming) [ ] ElevenLabs (WebSockets, streaming) [ ] Deepgram (streaming, low-latency)

Kokoro advantages: ✓ Native SageMaker integration (if you use AWS) ✓ Low latency (200ms first audio) ✓ Natural voice quality ✓ Cost-effective

Step 3: Implement streaming (week 3-4)

[ ] Set up Kokoro on SageMaker [ ] Modify LLM to stream tokens (not wait for full response) [ ] Create TTS stream handler (process tokens as they arrive) [ ] Send audio chunks to customer immediately [ ] Test with real customers (A/B test)

Step 4: Measure and optimize (week 5+)

[ ] Track time-to-first-audio (target: <300ms) [ ] Monitor call completion rate (target: >90%) [ ] Measure CSAT (target: >8.5/10) [ ] Optimize token batching (balance latency vs quality) [ ] Roll out to all customers

---

Bottom line: Latency is the silent killer

Your voice agent right now:

Agent capability: Excellent (LLM is smart, answers fast) TTS quality: Excellent (natural voice) Latency perception: Terrible (customer hears silence for 5 sec) Result: Agent seems broken (even though it's not) Outcome: Customer abandonment, lost revenue

With Kokoro streaming:

Agent capability: Excellent (same LLM, same answers) TTS quality: Excellent (same natural voice) Latency perception: Excellent (customer hears response in 200ms) Result: Agent feels responsive (like human) Outcome: Customer engagement, more revenue

Difference: Not agent capability, just TTS streaming Impact: 60-130% improvement in agent adoption

Decision:

Option 1: Keep current TTS (buffering) Pro: No work Con: Lose 40% of customers (abandonment) Cost: R$375k/year in lost revenue

Option 2: Implement Kokoro streaming Pro: 60-130% more customers, happier users Cost: R$50k/year (infrastructure) ROI: R$325k/year profit Timeline: 4 weeks to implement

Which wins? Kokoro. Only question is when.

→ OpenClaw: Voice Agent Latency, TTS Streaming, Real-Time Speech Synthesis, Customer Experience, Voice UX Optimization, Low-Latency Agent Architecture

Seu voice agent gera resposta em 350ms mas customer ouve em 5 segundos (TTS delay). Acha lento? É. Kokoro streaming: 200ms perceived latency. 60%+ mais customers completam conversa. Implementa em 4 semanas. ROI: R$325k/ano. Comece agora. 🎙️⚡✨