OpenAI's GPT-Realtime-2.1 Brings Better Reasoning and 25% Lower Latency to Voice Agents

OpenAI has pushed two new models to the Realtime API: gpt-realtime-2.1 and gpt-realtime-2.1-mini. Alongside the model updates, OpenAI has also cut p95 latency by at least 25% across all Realtime voice models through improved caching. If you’re building voice agents or any application on top of the Realtime API, this is a meaningful step forward on both capability and responsiveness.

What the Realtime API actually does

Before getting into the specifics, it’s worth grounding this. The Realtime API processes and generates audio through a single model rather than chaining together separate speech-to-text and text-to-speech systems. That matters because the traditional pipeline approach adds latency at every handoff and loses the natural qualities of speech along the way. The Realtime API streams audio bidirectionally over WebRTC, WebSocket, or SIP, making it the practical foundation for production-grade voice agents and live conversational interfaces.

GPT-Realtime-2 was OpenAI’s first voice model with GPT-5-class reasoning capable of handling harder requests mid-conversation. The 2.1 update builds directly on that.

What’s new in GPT-Realtime-2.1

GPT-Realtime-2.1 refines its predecessor across a few areas that matter most in real conversations:

Alphanumeric recognition has been improved, so the model handles things like order numbers, reference codes, and addresses more reliably when spoken aloud.
Silence and noise handling is better, meaning the model is less likely to mishear ambient noise as speech or get confused by pauses.
Interruption behaviour has been tuned so the model responds more naturally when a user cuts in mid-response.

It supports speech-to-speech interactions with configurable reasoning effort, instruction following, and tool use, making it suited to voice agents that need to do real work, not just answer simple questions.

GPT-Realtime-2.1-mini: reasoning at mini cost

GPT-Realtime-2.1-mini is a distilled reasoning model built for speed and cost efficiency. The key addition here is that the mini tier now includes reasoning and tool use (function calling), which the previous mini model lacked. That brings it into line with the full model for capability, at a significantly lower price point and with faster response times.

Pricing tells the story clearly. Audio output for gpt-realtime-2.1 costs $64.00 per million tokens. For gpt-realtime-2.1-mini, that drops to $20.00. That’s roughly a 3x gap on the most expensive token type, which adds up quickly in a production voice agent handling thousands of conversations.

Configurable reasoning effort

One of the more practical features in both models is adjustable reasoning effort. Developers can set it to minimal, low, medium, high, or xhigh. Low is the default and keeps latency down for straightforward turns. Higher settings increase both reasoning depth and output token usage, so they’re best reserved for tasks that genuinely need it.

OpenAI’s guidance is to start at low for most production voice agents and increase only where the task complexity warrants it. That’s sensible. For a customer support bot answering common questions, low effort is probably fine. For a voice agent that needs to reason through a multi-step problem before calling a tool, bumping up to medium or high makes sense.

The silent tool call problem, solved

There’s a specific pain point in voice agent design that reasoning directly addresses. When a model fires a function call, it typically goes quiet while waiting for the result. Users hear silence, assume the call has dropped, and interrupt. That breaks conversation state and creates confused, partial results.

With reasoning enabled, the model can plan its action and speak a natural preamble first: “Let me pull up that order for you.” It continues talking while it works through the request, keeps the user informed, and completes the tool call coherently. That shift from silent-to-responsive behaviour is what makes multi-step voice workflows actually usable.

25% lower p95 latency through caching

The latency improvement applies across all Realtime voice models, not just the new 2.1 releases. OpenAI achieved this through improved caching. When input tokens in a response match tokens from a previous response in the same session, cached pricing applies (and latency drops accordingly).

The practical implication: the best way to maximise cache hit rate is to keep a session’s history static rather than restructuring it between turns. If your implementation regularly rewrites or reorders the conversation context, you’re leaving latency savings on the table.

Cached token pricing is also worth noting. For gpt-realtime-2.1, cached audio input drops from $32.00 to $0.40 per million tokens. For gpt-realtime-2.1-mini, it drops from $10.00 to $0.30. Those aren’t rounding errors — caching is doing real work on cost as well as speed.

Full pricing at a glance

gpt-realtime-2.1 (per 1M tokens):

Text input: $4.00 / Cached: $0.40
Text output: $24.00
Audio input: $32.00 / Cached: $0.40
Audio output: $64.00

gpt-realtime-2.1-mini (per 1M tokens):

Text input: $0.60 / Cached: $0.06
Text output: $2.40
Audio input: $10.00 / Cached: $0.30
Audio output: $20.00

Which model should you use?

Use gpt-realtime-2.1 when you need the strongest reasoning, complex tool use, or precise instruction following, for example a voice agent handling financial queries, technical support, or anything where accuracy matters more than cost.

Use gpt-realtime-2.1-mini when you want faster responses and lower cost while still having reasoning and tool use available. It’s well suited to high-volume applications where the average query doesn’t require heavy reasoning, but the model still occasionally needs to call a function or work through a multi-step request.

Both models are available now through the OpenAI Realtime API. If you’re still on the Realtime API Beta interface, note that it was deprecated and removed on 12 May 2026, so migration to the released API is overdue if you haven’t made the switch.