How do I do live transcription with stable partials so captions or a voice agent don’t lag or flicker?

Most live voice products break the moment your transcription starts lagging or flickering. Captions jump around. Voice agents rephrase mid-sentence. Users lose trust. The root cause is usually unstable partial transcripts or a streaming stack that wasn’t designed for low-latency, low-variance updates.

Quick Answer: You get stable, low-latency live transcription by using a streaming STT engine that emits fast partials (<100 ms), aggressively stabilizes them, and exposes word-level timestamps and diarization over WebSocket—so your captions or agent logic can update smoothly without reflowing the whole text.

---

Quick Answer: Use a real-time STT API (typically over WebSocket) that supports incremental partials, word-level timestamps, and a stability strategy (like partial freezing or segment commits), then wire your client UI or agent logic to only “promote” partials once they cross a confidence or time threshold.

Frequently Asked Questions

How do I get live transcription that feels instant but doesn’t constantly rewrite itself?

Short Answer: You need a streaming engine that emits partial transcripts in under ~100 ms but also stabilizes those partials so they don’t keep changing. In practice, that means low-latency decoding plus a stability strategy for how partials are revised and committed.

Expanded Explanation:
In real meetings or calls, the main failure mode isn’t just “slow captions.” It’s captions that appear fast but flicker every few hundred milliseconds as the model revises its guess. For a voice agent, the same problem shows up as intent thrashing—your NLU input keeps changing, so your agent can’t decide what’s being said.

A production-grade system solves this with three layers:

1. Low-latency streaming – Audio flows via WebSocket; the model decodes continuously and returns partials in <100 ms.
2. Stability policy – The engine minimizes backward edits and exposes enough structure (timestamps, segmentation) so you can decide when to treat words as “final.”
3. UI/agent buffering – Your captions or agent logic buffer and “promote” partial content to final only when it’s stable enough—usually based on time since emission, punctuation, or word-level confidence.

Gladia’s Solaria-1 engine was built specifically for this: it delivers multilingual streaming transcription with partials in <100 ms and end-to-end latency <300 ms, while keeping partial revisions predictable enough to drive subtitles and live agent logic without flicker.

Key Takeaways:

• Fast partials are essential, but you also need control over how and when they stabilize.
• Word-level timestamps and segment boundaries let you implement your own promotion rules.
• A stable streaming engine + minimal client buffering = captions that feel live but don’t thrash.

---

What’s the actual process to implement live transcription with stable partials?

Short Answer: Open a WebSocket to a real-time STT API, stream raw audio in small chunks, consume partial transcripts as they arrive, and implement a simple buffering layer that only commits stable text to your captions or agent pipeline.

Expanded Explanation:
From a developer perspective, “stable partials” is mostly about wiring. You need the STT engine to do the heavy lifting (low latency, diarization, language detection), but the UX depends on how you handle those partials in your client or backend.

With Gladia, you use a single real-time endpoint over WebSocket. You stream PCM audio (8 kHz telephony or 16 kHz+ for apps) and receive JSON messages containing partials, finalized segments, timestamps, and optional diarization. Your code then:

• Updates an on-screen caption line with partials.
• “Locks in” words once they’re no longer being edited.
• Feeds stable segments into downstream workflows—summaries, NER, agent NLU.

Because performance is stable (predictable latency and WER across noisy audio, accents, and crosstalk), your buffering rules can be simple and still hold up in production traffic.

Steps:

1. Open a WebSocket connection to Gladia’s real-time API with your auth token and configuration (language auto-detect, diarization on/off, translation on/off).
2. Stream audio frames (e.g., 20–60 ms chunks in linear PCM) as soon as they’re captured from your client, SIP trunk, or media server.
3. Handle partial and final messages: update captions from partials, then mark text as final when the API signals segment completion or when your own stability threshold is met.

---

What’s the difference between “fast partials,” “stable partials,” and “final results”?

Short Answer: Fast partials are early guesses; stable partials are early guesses that don’t change much; final results are segments the engine considers complete and won’t revise further.

Expanded Explanation:
These three concepts often get conflated, but they map directly to UX behavior:

• Fast partials are about latency: “How quickly do I see the words after they’re spoken?” Gladia aims for <100 ms from audio to partial text.
• Stable partials are about variance: “How much do those words change over time?” A good engine minimizes backward edits and avoids full-line rewrites.
• Final results are about completeness: “Is this segment done?” Finalized segments are committed with timestamps and (optionally) speaker tags, and used for summaries, analytics, and storage.

You typically want all three: ultra-low-latency partials for responsiveness, stability for UI/agent reliability, and final results for downstream workflows and auditability.

Comparison Snapshot:

• Option A: Fast but unstable partials
  • Detail: Very quick updates, frequent rewrites; subtitles/agent state flicker.
• Option B: Slower but stable partials
  • Detail: Higher latency, fewer changes; captions trail the speaker.
• Best for:
  • Live products need “fast and stable.” That’s where engines like Solaria-1 focus: partials in <100 ms, overall latency <300 ms, constrained revision behavior, and structured output so your UI can balance speed vs. stability.

---

How do I wire this into my captions or voice agent without building a full infra team?

Short Answer: Use a single real-time STT API that gives you partials, timestamps, diarization, and optional NER/summarization, then plug it into your existing stack (browser, mobile, or telephony) via a small client and a lightweight backend relay.

Expanded Explanation:
You don’t need to rebuild your architecture to get stable live transcription. In most cases, you add a thin WebSocket client that streams audio and a “text orchestrator” that handles partials and finals.

With Gladia, you can:

• Browser/mobile apps: Capture microphone audio, send it to your backend over WebRTC/WebSocket, then relay to Gladia’s real-time endpoint. Update captions or agent state from the transcript messages.
• Telephony (SIP, 8 kHz): Tap into your media server (Twilio, Vonage, Telnyx, etc.), forward raw 8 kHz audio to Gladia’s telephony-optimized stream, and use the output to power live agent assist or IVR logic.
• Voice agents (Vapi, Pipecat, LiveKit, etc.): Connect Gladia’s streaming STT into your orchestration layer so the agent always sees stable, diarized text, not noisy ASR output.

Because Gladia exposes everything through one API—async + streaming + add-ons like summarization and NER—you don’t have to juggle separate services for captions vs. analytics vs. CRM enrichment.

What You Need:

• A way to capture and forward audio (browser mic, mobile, SIP media, or voice stack integration).
• A lightweight WebSocket client/relay that connects to Gladia’s real-time API, buffers partials, and surfaces stable text to your UI or agent.

---

Strategically, why does “stable partial” behavior matter for my product outcomes?

Short Answer: Stable partials directly impact user trust, automation reliability, and support costs—if your STT stream flickers or lags, your notes, summaries, and CRM syncs break, and your support team spends time cleaning up.

Expanded Explanation:
When STT is unstable, every downstream workflow suffers:

• Note-takers & meeting bots: Flickering captions and misattributed speakers mean inaccurate summaries and missed action items. Users stop relying on the tool.
• Voice agents & IVR: Intent detection becomes brittle. An unstable transcript causes agents to misreact or ask users to repeat themselves, pushing call handle time up.
• CRM & analytics: Names, emails, numbers, and entities get mangled. Dashboards become unreliable, and teams revert to manual entry.

By investing in an engine and integration pattern that produces stable partials under real-world conditions—noisy rooms, accented speech, crosstalk, 8 kHz telephony—you reduce variance in your core KPIs: handle time, resolution rate, and post-call cleanup.

Gladia anchors this in measurable behavior: open benchmarks across 7+ datasets and 500+ hours of audio, with reproducible methodology, and a real-time engine tuned specifically for conversational speech and speaker diarization. That’s how you treat STT as infrastructure rather than a “nice-to-have” feature.

Why It Matters:

• Trust and adoption: Users adopt voice features when captions and summaries consistently match what was said—no flicker, no missing speakers.
• Automation that doesn’t break: Stable transcripts are the backbone for reliable summaries, NER, CRM enrichment, and agent assist. When the text is stable, everything downstream can be automated with confidence.

---

Quick Recap

Live transcription that doesn’t lag or flicker comes from the combination of a low-latency, stable streaming engine and a thin buffering layer in your product. You stream audio over WebSocket, consume partials in <100 ms, and promote only stable pieces of text into your captions or agent logic. Gladia’s Solaria-1 engine is built for exactly this production reality—multilingual, telephony-ready, benchmarked on noisy conversational audio, and exposed through a single API that powers real-time captions, summaries, and CRM workflows without variance spikes.

Next Step

Get Started