GPTMap

GPT-Realtime-2.1 End-to-End vs ASR+LLM+TTS Pipelines: Choosing a Voice Architecture

For voice products: Realtime end-to-end or a self-assembled ASR+LLM+TTS pipeline? A five-dimension comparison (latency, interruption, control, deployment, multilingual) plus scenario-based recommendations.

TL;DR
GPT-Realtime-2.1 is the end-to-end route: one WebRTC / WebSocket connection for voice in and out, with native interruption and tool calling. The ASR+LLM+TTS pipeline is the assembly route: stages independently replaceable, but latency accumulates and interruption is DIY. Pick by scenario: conversation feel, per-stage control, or pure translation (GPT-Realtime-Translate).
The end-to-end route for voice uses a Realtime-class model over a single connection for speech in and speech out; the pipeline route chains automatic speech recognition (ASR), a large language model (LLM), and text-to-speech (TTS) as independently selected stages. The difference is a trade between experience integration and engineering control.

The end-to-end route for voice uses a Realtime-class model over a single connection for speech in and speech out; the pipeline route chains ASR, LLM, and TTS as independently selected stages. The difference is a trade between experience integration and engineering control: end-to-end builds the human-like details (interruption, turn-taking, tool calling) into the model, while the pipeline leaves the system-like details (cost, auditing, replacement) to you. This article compares the two across five dimensions and closes with scenario-based recommendations.

1. What the Two Routes Look Like

End-to-end (the GPT-Realtime-2.1 route): one WebRTC or WebSocket connection between client and model, voice streaming in and out. GPT-Realtime-2.1, released 2026-07-06, is the current voice flagship; 2.1 mini, released the same day, targets cost-sensitive high-concurrency workloads. The model natively supports mid-conversation interruption and tool calling -- checking an order mid-chat without ending the conversation.

The pipeline (ASR -> LLM -> TTS): three stages selected independently -- ASR transcribes, the LLM stage runs business logic on GPT-5.6 models, TTS synthesizes. Your code sits between the stages: you can add per-stage caching, auditing, and degradation, and you also own inter-stage latency and state.

DimensionEnd-to-end (GPT-Realtime-2.1)Pipeline (ASR + LLM + TTS)
ConnectionWebRTC / WebSocket long connectionOrdinary HTTP calls chained in three stages
LatencyStructurally better: two fewer cross-stage round tripsAccumulates per stage; hard to catch up even optimized
InterruptionNative in the modelBuild it yourself (echo cancellation, turn management)
Tool callingNative mid-conversationFunction calling in the LLM stage; you glue conversation state
ControlSession-level configurationEach stage replaceable, auditable, degradable
BillingPer realtime sessionThree separate bills; the LLM stage can use Prompt Caching
MultilingualGPT-Realtime-Translate streams translation directlyAssemble the translation stage yourself

2. Latency: The Structural Advantage of End-to-End

Every pipeline turn goes through "user speaks -> ASR finishes -> LLM finishes -> TTS finishes" serially. Even with each stage squeezed, cross-stage network and processing overhead is structural. The end-to-end route streams voice straight into the model and straight out -- which is why interruption is "native" there: the model is always listening and can stop at any moment.

The pipeline's counterpoint: non-conversational work has no latency anxiety. Batch transcription, offline summaries, and generated voiceovers can be two seconds late; the pipeline's flexibility and unit cost win there. Latency is a hard requirement for conversational products -- not every voice need is conversational.

3. Control: The Engineering Value of the Pipeline

End-to-end builds the experience into the model -- and the black box too. The pipeline's three stages are separate engineering nodes:

  • Auditing and compliance: the LLM stage's inputs and outputs are text, so content filtering and sensitive-word checks are standard engineering; voice streams make that layer harder.
  • Independent optimization: the LLM stage gets its own prompt engineering, model swaps, and Prompt Caching; the TTS stage can change voice vendors. Progress in any stage benefits immediately.
  • Degradation and failover: if TTS dies, fall back to text replies; ASR vendors can be canary-swapped. The pipeline's failure granularity is finer.

One line: choose end-to-end for "conversation that feels human," pipeline for "control that feels like a system."

4. Multilingual and Special Cases

Cross-language work has a shortcut: GPT-Realtime-Translate (released 2026-05-07) is built for streaming speech-to-speech translation -- voice in, target-language voice out, no "recognize -> translate -> synthesize" assembly. Multilingual meetings and bilingual support should use it directly.

For streaming transcription, GPT-Realtime-Whisper (released 2026-05-07) provides realtime speech-to-text. Pure transcription needs (meeting notes, captions) work fine as STT plus LLM post-processing -- a full Realtime session is unnecessary.

5. Scenario-Based Recommendations

Your scenarioRecommendationWhy
Voice customer service / companionshipEnd-to-end GPT-Realtime-2.1Interruption and turn-taking are the product
High-concurrency voice assistant (cost-sensitive)End-to-end 2.1 miniKeeps realtime feel, lower tier
Multilingual meetings / bilingual supportGPT-Realtime-TranslateStreaming translation in one connection
Batch transcription / meeting notesSTT + LLM pipelineNo realtime requirement; flexible and cheaper
Voice interaction under strict compliancePipeline (or hybrid)Audit and degrade the text stage separately
Complex business logic in the LLM stagePipelineFunction calling plus your own code fit better

Hybrid routes exist too: streaming STT as the base, Realtime for the conversation core, TTS engaged only when needed -- assemble per scenario rather than dogmatically picking one.

6. Migration Note: The Beta Era Is Over

The Realtime API Beta was removed on 2026-05-12 -- if you are still on the Beta interface, migrating to the current Realtime API is mandatory, not optional. The current integration is GPT-Realtime-2.1 / 2.1 mini over WebRTC / WebSocket; the official Realtime guide covers connections, sessions, and tool calling end to end.

Frequently Asked Questions

1. Which scenarios require Realtime end-to-end?

Three: natural interruption (the model stops mid-sentence when the user jumps in), mid-conversation tool calling (checking an order without leaving the conversation), and latency-sensitive conversational products (voice customer service, companionship). Building these in a pipeline means rolling your own, and matching the naturalness is hard.

2. When is a pipeline the better choice?

Three cases: the LLM stage needs complex business logic or strict compliance auditing (a pipeline can audit and degrade the text stage separately); batch processing rather than live conversation (no latency anxiety); or you have mature ASR / TTS assets to reuse. Every pipeline stage can be swapped and load-tested independently.

3. GPT-Realtime-2.1 or 2.1 mini?

2.1 is the voice flagship (released 2026-07-06) for experience-first scenarios; 2.1 mini is the low-cost tier for high-concurrency use cases that are less sensitive to voice quality and interruption detail. Both connect through the Realtime API's WebRTC / WebSocket.

4. What about pure translation scenarios?

Do not assemble one. GPT-Realtime-Translate (released 2026-05-07) is streaming speech-to-speech translation: voice in, target-language voice out. For multilingual meetings and bilingual support, a pipeline is redundant.

5. How do the cost structures differ?

End-to-end bills per realtime session with both directions on the model side; the pipeline bills each stage separately, and the LLM stage can benefit from Prompt Caching on its own. For exact prices check the official pricing page (this article quotes no numbers); model your own cost as target-session length times turns.

6. Is the old Realtime API Beta still available?

No. The Realtime API Beta was removed on 2026-05-12; the current era is GPT-Realtime-2.1 / 2.1 mini. Apps still on the Beta interface must migrate to the current Realtime API over WebRTC / WebSocket.

Next Steps

Key points

  • GPT-Realtime-2.1 (2026-07-06) runs over WebRTC / WebSocket long connections with native interruption and mid-conversation tool calling
  • The pipeline's ASR -> LLM -> TTS stages are independently selectable: the LLM stage can run GPT-5.6 models with its own prompt engineering and caching
  • End-to-end wins latency structurally: two fewer cross-stage round trips; pipelines rarely catch up even when fully optimized
  • Pipelines win control: each stage can be replaced, audited, and degraded independently, and the LLM stage's business logic is easier to build
  • For pure translation use GPT-Realtime-Translate (2026-05-07) -- streaming speech-to-speech, no assembly required
  • The old Realtime API Beta was removed on 2026-05-12 -- choosing end-to-end today means GPT-Realtime-2.1 / 2.1 mini

Frequently asked questions

Three: natural interruption (the model stops mid-sentence when the user jumps in), mid-conversation tool calling (checking an order without leaving the conversation), and latency-sensitive conversational products (voice customer service, companionship). Building these in a pipeline means rolling your own, and matching the naturalness is hard.

Official references

Related articles

Subscribe to GPTMap Weekly

One email every Monday: curated OpenAI updates, deep dives, and best practices. No ads, unsubscribe anytime.

GPTMap EditorialPublished 2026-08-30 6 min read
Test environment (EEAT)
Last tested: 2026-08-30
Model used: gpt-5.6