Grok Voice 2.0: Thinking While Speaking, 8 Cents per Minute

Grok Voice Think Fast 2.0 Launches, Will Automatically Take Over latest on August 5

On July 29, Elon Musk’s SpaceXAI (xAI) released its next-generation speech-to-speech model, Grok Voice Think Fast 2.0. The company describes it as the most capable and intelligent Grok Voice model to date. Rather than simply adding more voices, the upgrade focuses on helping voice agents understand users better, act sooner, and make fewer mistakes when listening to noisy phone calls.

Pricing was also announced: $0.08 per minute of audio, equivalent to approximately RMB 0.54 at current exchange rates. That works out to about $4.80, or roughly RMB 32, for one continuous hour of audio processing. If a business consumes 100,000 minutes per month, model costs would be approximately $8,000, excluding phone lines, log storage, monitoring, and other infrastructure expenses.

On August 5, 2026, xAI will switch grok-voice-latest from grok-voice-think-fast-1.0 to grok-voice-think-fast-2.0. Applications using the latest alias will not need to change the model name. Those not ready to upgrade should pin their applications to grok-voice-think-fast-1.0 before the switch.

The most noteworthy aspect of this release is not the benchmark scores themselves, but xAI’s explicit focus on voice agents in production environments: whether the model can respond quickly after the user finishes speaking, and whether it can complete tool calls before finishing its own first sentence.

“Think Fast” Does Not Mean Thinking Less, but Hiding the Thinking Within the Speaking Process

Traditional voice agents are often assembled as a three-stage pipeline:

1. ASR converts the user’s speech into text;
2. A large language model interprets the request and decides whether to call a tool;
3. TTS synthesizes the text response back into speech.

This architecture is easy to control and makes individual components easy to replace, but latency accumulates at each stage. After the user stops speaking, the system must still wait for transcription to finish, generate an answer, and then start speech synthesis. If any stage takes a few hundred milliseconds longer, the delays add up and create the distinct impression that “the person on the other end of the line has frozen.”

Grok Voice Think Fast 2.0 takes an end-to-end speech-to-speech approach. According to xAI, the new model can continue reasoning while producing speech, without introducing an additional silent pause to achieve stronger reasoning. One way to think about it is that, rather than writing an entire script internally before reading it aloud, the model behaves like a human customer service representative: it first responds naturally with, “Sure, let me check that for you,” while simultaneously completing identity verification, order lookup, or appointment scheduling in the background.

The company also says that the new version uses fewer reasoning tokens per response. In real production environments, tool calls can usually be completed before the agent finishes speaking its first sentence.

For voice applications, this capability matters far more than “providing longer answers.” If a web chat takes two seconds longer, users may simply assume the model is thinking. If a phone call goes silent for two seconds, users are more likely to ask, “Hello, are you still there?” The baseline quality of a voice agent is often determined not by intelligence, but by turn latency, interruption handling, and error recovery.

Quality Index Rises to 82.9%, but Do Not Focus on a Single Overall Score

According to speech-to-speech benchmark results published by Artificial Analysis, Grok Voice Think Fast 2.0 achieved an AA Speech-to-Speech Quality Index of 82.9%, compared with 75.7% for the previous-generation Think Fast 1.0—an increase of 7.2 percentage points.

That is a substantial gain for a generational update. It suggests that the new model is not merely a minor refinement to voice naturalness, but an across-the-board improvement in speech understanding, response quality, and end-to-end interaction. However, the overall score still cannot directly answer several questions that matter most to developers:

• How quickly does the model stop speaking when the user interrupts?
• What is the error rate for dialects, accents, strings of numbers, and proper nouns?
• If a tool call fails, will the model fabricate a successful result?
• Does context remain stable during long calls, and do costs increase linearly?
• How exactly are input, output, and overlapping audio counted under “one minute of audio” billing?

The 82.9% score is therefore better suited for determining whether the model deserves a place on the testing shortlist than for replacing production A/B tests. Voice models ultimately need to be validated against each company’s own phone lines, customer accents, product vocabulary, and tool interfaces.

Transcription Is Another Major Focus of This Upgrade

xAI says that, in its internal evaluation covering thousands of phrases across 24 languages, Think Fast 2.0 delivered transcription performance 1.5–2.0 times better than Deepgram Nova 3 and ElevenLabs Scribe v2, and 1.4 times better than Grok Voice Think Fast 1.0.

Under conditions involving heavy background noise and compression through telephone networks, xAI even claims that the new model’s advantage over some specialized speech-to-text models can widen to approximately tenfold.

These figures are striking, but they require two important qualifiers: internal evaluation.

First, “1.5 times better” does not necessarily mean that the word error rate fell by 50%. Its precise meaning depends on whether xAI used accuracy, error rate, or a composite scoring method. Second, phrase-based testing is not identical to real-world phone calls. Customer service calls often contain overlapping speakers, pauses, repetition, self-correction, and long-tail entities such as order numbers, personal names, and place names, all of which are generally more difficult than standardized short sentences.

Even so, xAI is right to make transcription accuracy a core selling point of an end-to-end model. Once a voice agent makes an error at the auditory input stage, stronger downstream reasoning may simply make it more confident in solving a problem that does not exist. For example, if the user says, “Don’t cancel the order,” but the model hears, “Cancel the order,” even a perfectly executed downstream tool call is useless.

$0.08 per Minute Is Not Cheap, but It Makes Costs Easy to Estimate

Think Fast 2.0 has a straightforward pricing model: $0.08 per minute of audio.

For development teams, per-minute pricing makes budgeting easier than separately calculating input audio tokens, output audio tokens, text tokens, and caching fees. For a customer service system handling 5,000 calls per day with an average duration of four minutes, estimated at 200,000 minutes per month, audio model costs alone would be approximately $16,000 per month.

Whether that price is worthwhile depends on how many peripheral components the model can replace.

If Think Fast 2.0 can handle transcription, reasoning, speech output, and tool orchestration simultaneously, teams may no longer need to purchase ASR, LLM, and TTS services separately or manage streaming connections and timestamp alignment themselves. The unit price may appear higher, but integration costs, points of failure, and end-to-end latency could all decrease.

Conversely, specialized asynchronous ASR is generally more suitable for meeting transcription, call-recording quality inspection, or batch subtitle generation. Buying full speech-to-speech capabilities for tasks that do not require real-time interaction is like hiring a private car to remain on standby for the entire trip just to deliver a document.

It is important to note that the company has so far provided only the broad pricing statement of “$0.08 per minute of audio.” Before scaling up, developers should still confirm whether input and output audio are billed separately, whether silence is billable, what concurrency limits apply, whether text tokens generated by tool calls incur additional charges, and how billing is handled when connections fail.

Tool-Calling Reliability Determines Whether It Can Move Beyond “Chatting” and Enter Business Systems

A voice model that sounds human mainly improves demos. Reliable tool calling determines whether it can take over real workflows.

Consider airline customer service. During a conversation, the model must extract the passenger’s name, flight number, and date, call the booking API, and then provide a quote based on change and cancellation policies. If the tool call is too slow, the agent can do little more than stall with “Please wait.” If the parameters are inaccurate, it may retrieve the wrong booking. If the model claims, “Your flight has been successfully changed,” even after the API call fails, the consequences are far more serious than merely being less efficient than a human agent.

Think Fast 2.0 emphasizes “completing tool calls before finishing the first sentence,” suggesting that xAI is optimizing the model for a more practical interaction pattern:

User makes a request → Agent responds with a natural acknowledgment → Tool is called in parallel in the background → Agent immediately reports the actual result.

xAI says that A/B tests in Starlink customer service and sales calls showed improvements in sales conversion rates and self-service issue resolution rates. At a minimum, this indicates that the new model has not only been benchmarked on laboratory datasets, but has also been tested in xAI’s own high-concurrency phone operations. However, because the company has not disclosed sample sizes, baselines, or the exact magnitude of the improvements, these results cannot yet be used to estimate benefits in other industries.

latest Will Upgrade Automatically, but Production Environments Should Not Follow Blindly

After August 5, grok-voice-latest will automatically point to 2.0. The company believes that the new model will improve nearly every use case and that existing prompts will generally not need to be modified.

For production systems, however, “no modification required” does not mean “no testing required.” A voice model upgrade may change pause duration, speaking speed, tool-call timing, parameter extraction behavior, or even sensitivity to user interruptions. Each change may be an improvement in isolation, yet still conflict with an existing workflow.

A more cautious migration process would be:

• Pin the test environment to 2.0 and replay a set of anonymized real-world calls;
• Compare time to first audio, total response latency, transcription error rates, and tool success rates;
• Check high-risk fields such as numbers, names, addresses, monetary amounts, and negations;
• Run an A/B test on a small percentage of traffic and retain a rollback switch;
• After validation, move the production environment from a pinned version back to latest.

Automatic upgrades are usually beneficial for consumer chat products. For agents handling payments, medical appointments, or logistics changes, pinning the model version remains the more professional choice.

OpenAI-Compatible API Example

Grok Voice Think Fast 2.0 is a proprietary commercial model. Developers in China who need to manage models from multiple providers through a unified interface can connect through an OpenAI-compatible aggregation API such as OpenAI Hub. Whether the voice model is already available, its corresponding model ID, and its Realtime event format should be confirmed through the platform’s console.

Speech-to-speech applications generally upload PCM audio continuously over WebSocket and receive streaming audio deltas. They are not suited to ordinary single-request Chat Completions calls. The following Python example illustrates an OpenAI Realtime-compatible layer, focusing on the process of establishing a connection, appending audio, and receiving results:

import os
import json
import base64
import websocket

api_key = os.environ["OPENAI_HUB_API_KEY"]
base_url = os.getenv(
    "OPENAI_HUB_REALTIME_URL",
    "wss://api.openai-hub.com/v1/realtime"
)
model = "grok-voice-think-fast-2.0"

ws = websocket.create_connection(
    f"{base_url}?model={model}",
    header=[
        f"Authorization: Bearer {api_key}",
        "OpenAI-Beta: realtime=v1"
    ]
)

# Configure the voice agent; refer to the actual compatible API
# documentation for exact field names
ws.send(json.dumps({
    "type": "session.update",
    "session": {
        "instructions": (
            "You are an after-sales voice assistant. Before looking up an "
            "order, you must repeat the order number. If a tool fails, you "
            "must not claim that the operation succeeded."
        ),
        "input_audio_format": "pcm16",
        "output_audio_format": "pcm16",
        "turn_detection": {"type": "server_vad"},
        "tools": [{
            "type": "function",
            "name": "query_order",
            "description": "Look up the status using the order number",
            "parameters": {
                "type": "object",
                "properties": {
                    "order_id": {"type": "string"}
                },
                "required": ["order_id"]
            }
        }]
    }
}))

# Example: read chunks of 16-bit mono PCM audio
with open("question.pcm", "rb") as audio_file:
    while chunk := audio_file.read(3200):
        ws.send(json.dumps({
            "type": "input_audio_buffer.append",
            "audio": base64.b64encode(chunk).decode("utf-8")
        }))

ws.send(json.dumps({"type": "input_audio_buffer.commit"}))
ws.send(json.dumps({"type": "response.create"}))

while True:
    event = json.loads(ws.recv())

    if event.get("type") == "response.audio.delta":
        audio_bytes = base64.b64decode(event["delta"])
        # In a real project, write this immediately to the player
        # or telephone media stream
        print("received audio bytes:", len(audio_bytes))

    elif event.get("type") == "response.function_call_arguments.done":
        print("tool call:", event)

    elif event.get("type") == "response.done":
        break

ws.close()

A real-world deployment would also need echo cancellation, jitter buffering, reconnection handling, idempotent tool calls, and sensitive-data redaction. Tool calls deserve particular attention: the system must not rely solely on the model’s verbal claim that an operation succeeded. The business backend must return a verifiable status, which the model can then report to the user.

Assessment: An Update Built for Production-Grade Voice Agents

Grok Voice Think Fast 2.0 does not focus on more human-like laughter or a larger selection of character voices. Instead, it targets the three most difficult challenges for voice agents: hearing accurately, responding quickly, and executing reliably.

The 82.9% quality index and claims of significantly outperforming specialized transcription models give the release a compelling narrative. The genuinely valuable features, however, are simultaneous speaking and reasoning, lower reasoning-token usage, and completing tool calls before the first sentence ends. If these capabilities can be reproduced in third-party applications, Think Fast 2.0 will look more like a deployable real-time agent engine than merely a chatbot that can speak.

Its shortcomings are equally clear. At $0.08 per minute, it is not a light expense for high-volume businesses with low average transaction values. The internal transcription evaluations still require independent validation, while the automatic upgrade mechanism requires production teams to establish version-governance procedures in advance.

In short, this upgrade is worth testing for voice customer service, telesales, in-vehicle assistants, and real-time appointment applications, but it does not justify a full migration based solely on the company’s claimed performance multipliers. Running a round of tests on real call recordings before replacing an existing ASR, LLM, and TTS pipeline is far more reliable than focusing on a single aggregate benchmark score.

References

• ITHome: SpaceXAI’s Most Intelligent AI Voice Model, Grok Voice Think Fast 2.0, Debuts—Includes the release date, model pricing, version migration schedule, and voice benchmark data.