Grok Voice 3.0 Explained: Benchmarks, Pricing and Speech-to-Speech (2026)

You shipped a voice agent last spring, it answered support calls well enough, and then a new model lands that scores much higher on the hardest benchmark while getting slower at saying its first word. Do you upgrade, pin the old version, or wait? That is the exact decision Grok Voice 3.0 puts in front of every team running on xAI's Voice Agent API. The model went live on October 14, 2026, the grok-voice-latest alias moved to it automatically, Grok Voice 2.0 was deprecated, and the price stayed at $0.08 per minute [3][1].

If you make videos, Shorts, or music and you are wondering what a voice-agent model has to do with your workflow, the short version is that the same speech-to-speech technology is what will eventually sit behind interactive narration, live co-hosts, and voice-driven editing tools. Creators who build with Miraflow's Text2Shorts already use synthetic voice every week, so understanding how the voice models underneath are evaluated helps you judge the next wave of voice features instead of trusting a headline score.

This post is a technical walkthrough of Grok Voice 3.0. It covers what changed from 2.0, how speech-to-speech differs from the older speech-to-text, language model, text-to-speech chain, how to read each benchmark xAI and Artificial Analysis quote, why time to first audio got slower while accuracy rose, a working WebSocket client built only from fields in xAI's documentation, the cost math per call, a migration plan, and a production architecture with the mistakes that cause most outages. A note on naming: xAI was folded into SpaceX earlier this year, and trade coverage now uses SpaceXAI and, since early October, SpaceXSI for the AI unit [8]. The API host is still api.x.ai and the docs still say xAI, so this post uses xAI for the company.

Quick Facts: Grok Voice 3.0 at a Glance

Everything below comes from xAI's own announcement, xAI's documentation, or Artificial Analysis, the independent evaluator whose index xAI cites. Where a figure comes only from xAI, the post says so.

• Release date: October 14, 2026, with benchmark data dated October 13 by Artificial Analysis [1][3].
• Model IDs: grok-voice-3.0 (flagship, reasoning on by default), grok-voice-latest (alias that currently points to 3.0), and grok-voice-2.0 (deprecated) [2].
• Price: $0.08 per minute, which is $4.80 per hour, identical to Grok Voice 2.0 [5][1].
• Artificial Analysis Speech-to-Speech Index: 86.9, first place, against 83.2 for GPT-Live-1 (Astra, medium) and 82.6 for Gemini 3.8 Live (Extended Thinking, High) [6].
• tau-Voice: 71.6 percent, up from 56.5 percent for Grok Voice 2.0, but still behind GPT-Live-1 at 74.5 percent [6][1].
• Time to first audio: 0.81 seconds, slower than 2.0 at 0.70 seconds and faster than GPT-Live-1 at 1.34 seconds [6].

Step 1: What Actually Changed From Grok Voice 2.0

The headline in every launch article is the index score, so it is worth separating what changed in the model from what stayed the same in the platform. On the platform side almost nothing moved. The endpoint is the same wss://api.x.ai/v1/realtime URL, the session parameters are the same, the events are the same, and xAI's migration note says to set the model field to 3.0 or to the latest alias at the same price [2][3]. That is deliberate. A speech-to-speech model is wired into telephony stacks, browser clients, and in-car software, and a breaking protocol change would be far more expensive for customers than a weaker benchmark.

On the model side, the changes are concentrated in agentic behavior. Artificial Analysis lists Grok Voice 3.0 against 2.0 across its components: speech reasoning moved from 97 to 99 percent, conversational dynamics from 95.1 to 97.0 percent, agentic performance on tau-Voice from 56.5 to 71.6 percent, arena preference Elo from 1011 to 1070, and task success from 94.6 to 94.8 percent [6]. Four of those five moves are small. The tau-Voice jump of 15.1 points is the one that carries the index, and it is the benchmark where agents must follow a policy, call tools, and change a database correctly while a simulated customer with an accent and background noise keeps talking [11].

That pattern tells you where xAI spent its effort. Speech reasoning was already near the ceiling at 97 percent, so the remaining gains had to come from multi-step work: verifying a customer, picking the right tool, reading the result, and speaking a correct next step. xAI's own description of the Starlink deployment matches this focus, since a single agent there verifies customers, troubleshoots hardware, issues credits, and ships replacement equipment [9]. xAI also reports that Starlink handles about 20,000 calls a day with roughly 70 percent resolved without a human, and that Tesla vehicles run on the same model. Those two numbers are vendor-reported and no independent party has audited them, so treat them as deployment evidence and not as a benchmark [1][8].

Reasoning Is on by Default

One documented detail deserves more attention than it has received. The docs describe grok-voice-3.0 as the flagship with reasoning on by default, and expose reasoning.effort with two values, "high" (the default) and "none" [2]. The page recommends "high" for complex multi-step instructions, nuanced tone, and ambiguous queries, and it does not publish a latency or cost trade-off between the two settings [2]. That gap matters because the 0.81 second time to first audio on the Artificial Analysis leaderboard was measured on the benchmark's default configuration. If you switch reasoning off for a simple FAQ line, you should measure your own latency rather than assume a number.

What the Docs Add Around the Model

Several session features documented alongside 3.0 are worth knowing because they remove work you would otherwise build yourself. resumption.enabled lets the server cache turns by conversation ID and replay them after a reconnect, with history expiring after 30 minutes of inactivity [2]. turn_detection.idle_timeout_ms re-prompts a silent caller after a delay you choose [2]. A replace map rewrites phrases before synthesis, so a product name like a brand with an unusual spelling is spoken correctly while the transcript keeps the original text [2]. Input transcription accepts up to 100 keyterms of 50 characters each and a BCP-47 language_hint [2]. None of these are new model capabilities, but together they cover the three things that break first in real deployments: dropped connections, dead air, and mispronounced names.

Step 2: Speech-to-Speech Versus the Cascaded Pipeline

To judge Grok Voice 3.0 you need a clear picture of the architecture it replaces. Until about 2024 nearly every voice assistant used a cascade: an automatic speech recognition model transcribes audio to text, a language model writes a text reply, and a text-to-speech model reads it aloud. OpenAI described exactly this arrangement for ChatGPT Voice Mode before GPT-4o, using three separate models, with average latencies of 2.8 seconds on GPT-3.5 and 5.4 seconds on GPT-4 [16]. OpenAI's own explanation of the cost of that design is that the main language model never hears tone, multiple speakers, or background noise, and cannot produce laughter, singing, or expressed emotion, because everything it sees has been flattened into text [16].

Why the Cascade Persists Anyway

Cascades remain popular for good reasons. Each stage is a separate, swappable component, so you can pair a strong recognizer such as Whisper, trained on 680,000 hours of multilingual supervised audio [17], with any language model and any voice. You can log and inspect the text between stages, run a content filter on it, and unit-test each piece in isolation. The cost is latency and information loss. The recognizer typically waits to decide a user has stopped speaking, the language model must receive the finalized transcript before it starts, and the synthesizer needs at least the first sentence before it can begin audio. Those waits add up, which is why a tuned cascade tends to land in the range of a second or more of dead air even when every component is individually fast.

What Speech-to-Speech Changes

A speech-to-speech model consumes audio and produces audio inside one network, so there are no stage boundaries to wait on. Research systems showed the principle first. AudioLM treated audio generation as language modeling over discrete tokens from a neural codec [18]. Moshi, from Kyutai, went further: it models its own speech and the user's speech as parallel streams, which removes explicit speaker turns, and predicts time-aligned text tokens before the audio tokens in a method it calls Inner Monologue, reporting a theoretical latency of 160 ms and 200 ms in practice [15]. Open models such as LLaMA-Omni showed that a text language model can be extended to generate speech directly with response latencies as low as 226 ms [19], and Mini-Omni demonstrated the same idea with streaming audio output [23].

xAI has not published Grok Voice 3.0's internal architecture, parameter count, or training data, so nothing in this section should be read as a description of its internals. What the docs do reveal is the interface of a speech-to-speech system: audio goes in through input_audio_buffer.append, audio comes out as response.output_audio.delta chunks, and server-side voice activity detection handles barge-in when turn_detection.type is "server_vad" [2]. The same events carry text transcripts and tool calls, which is why these models can act and not only talk.

Where Speech-to-Speech Still Costs You

Speech-to-speech is not free of trade-offs. You lose the clean text checkpoint between recognition and generation, so guardrails must work on a transcript produced alongside the audio and not on the input the model actually reasoned over. You also depend on one vendor's voices, whereas a cascade lets you plug in any synthesizer. For creator tooling the same trade shows up in a simpler form: a dedicated voice product such as the models covered in our ElevenLabs Eleven v4 breakdown wins on voice quality and control, while a speech-to-speech agent wins on conversational flow. If you want the full-duplex side of this story, our explainer on OpenAI's GPT-Live architecture walks through the decision loop that replaces silence detection, and our post on Amazon Nova 2 Sonic covers another production speech-to-speech model.

Step 3: How to Read the Benchmarks Behind the 86.9

A single index number hides four different tests, each with its own weakness. The Artificial Analysis Speech-to-Speech Index is an equal-weighted score across four components: speech reasoning (Big Bench Audio), agentic performance (tau-Voice), arena preference, and task success rate, and a model needs results for all four to receive a score [6][7]. Because the weights are equal, a model can climb the index by being excellent at the cheap tests while staying mediocre at the expensive one. Reading each component separately is the only way to know what the headline means for your use case.

Big Bench Audio: Speech Reasoning

Big Bench Audio consists of 1,000 audio questions, 250 each from four Big Bench Hard categories: Formal Fallacies, Navigate, Object Counting, and Web of Lies. The questions are voiced by 23 synthetic voices, and the model under test receives only the audio question. Its spoken reply is transcribed, and a judge model compares the answer to the official answer and marks it correct or incorrect [22][21]. The score therefore measures whether reasoning survives the trip through audio. Grok Voice 3.0 scores 99 percent on the Artificial Analysis table and 98.5 percent in xAI's own chart, a small difference that likely reflects rounding or run conditions, and either way the test is close to saturated. A one-point gap at the top says very little about real calls, where speech is messy and the tasks are not logic puzzles.

The same run produces the cost figure xAI quotes. Cost per Big Bench Audio task is $0.025 for Grok Voice 3.0, $0.030 for GPT-Live-1 (Astra, medium), and $0.055 for GPT-Realtime-2.1 (High) [9]. That makes Grok about 17 percent cheaper than GPT-Live-1 and about 55 percent cheaper than GPT-Realtime-2.1 on this specific task, though a puzzle with a short question and a short answer is not a typical call, so the ratio is more informative than the absolute dollar amount.

tau-Voice: The One That Matters for Agents

tau-Voice comes from the team behind tau-bench. The original tau-bench placed a language model agent in simulated customer-service domains with a simulated user, scored by comparing the final database state to the goal state, and introduced pass^k to measure whether an agent succeeds reliably across repeated trials and not just once [12]. tau-Voice extends that to full-duplex voice, with 278 tasks, a voice user simulator offering diverse accents and noisy environments, and deterministic scoring [11]. The paper's central finding is a capability gap: voice agents retained only a fraction of what the same underlying model could do in text, with 79 to 90 percent of failures attributed to agent behavior and not to the simulator in the published version [11]. The preprint and the peer-reviewed version report different absolute numbers for the baseline models, so cite the version you are looking at.

Here is the part most launch coverage glosses over. On tau-Voice, GPT-Live-1 (Astra, medium) scores 74.5 percent and Grok Voice 3.0 scores 71.6 percent [6][1]. Grok did not win the hardest test. xAI frames its result as comparable to GPT-Live-1 at 40 percent lower latency, and the Artificial Analysis table supports that framing: 0.81 seconds against 1.34 seconds is a 39.6 percent reduction [6][1]. The honest summary is that Grok Voice 3.0 wins the index through reasoning, conversational dynamics, task success, and speed, while trailing the best competitor by 2.9 points on the most agent-like test.

Full-Duplex-Bench: Conversational Dynamics

Full-Duplex-Bench evaluates four interactive behaviors with automatic, reproducible metrics: pause handling, backchanneling, turn-taking, and interruption management [14]. Artificial Analysis uses a subset of versions 1 and 1.5 for its Conversational Dynamics column [6]. Grok Voice 3.0 posts 97.0 percent, up from 95.1 percent for 2.0, ahead of GPT-Live-1 (Astra, medium) at 94.9 percent. One caution from the same table: GPT-Live-1 (Sol, low) scores 97.3 percent here, higher than Grok, so this metric also does not give Grok a clean sweep [6].

Arena Preference and Task Success

Arena preference is human pairwise preference after scenarios run with two unidentified models, converted to an Elo-style score, and the index uses a rating frozen when the model first becomes eligible [6]. Task success is the share of eligible conversations that end with the correct task-completing tool calls [6]. Grok Voice 3.0 reaches 94.8 percent on task success against 87.4 percent for GPT-Live-1 (Astra, medium), which is the widest margin in the table, but it is also the component with the least published methodology, so it deserves the most skepticism and the most testing on your own scenarios.

EVA-Bench: The Enterprise Cross-Check

xAI also cites ServiceNow's EVA-Bench, where it reports 74 percent accuracy and the best result when accuracy and experience are scored together [1]. EVA-Bench is an open-source framework with bot-to-bot audio conversations across 213 scenarios in three enterprise domains, plus perturbation suites for accents and noise. It scores accuracy (EVA-A) and conversational experience (EVA-X) separately and reports pass@1, pass@k, and pass^k, which separate peak performance from reliable performance [13]. In the paper's evaluation of 12 systems, none scored above 0.5 on both EVA-A and EVA-X at pass@1, and the median gap between peak and reliable accuracy was 0.44 [13]. The 74 percent for Grok is the vendor's report, and ServiceNow's quote that the model sets a new Pareto frontier is a favorable but non-independent endorsement. It remains useful because EVA-Bench's pass^k framing reminds you that a single successful run proves little.

A Checklist for Reading Any Voice Benchmark

• Check whether the headline is a mean of components and which component is the weakest.
• Check who ran it: vendor chart, independent evaluator, or a customer.
• Check the number of trials, since tau-Voice results are averaged across three trials where available [9].
• Look for pass^k or a similar reliability measure before trusting a pass rate for production.
• Compare latency measured on the same benchmark, not a marketing claim.

Step 4: The Latency Versus Accuracy Trade-Off

The surprising line in the Artificial Analysis table is that Grok Voice 3.0's time to first audio is 0.81 seconds, slower than Grok Voice 2.0 at 0.70 seconds [6]. That is a 0.11 second increase, or about 16 percent, in exchange for a 15.1 point gain on tau-Voice. Meanwhile xAI's own page says only "class-leading latency at under one second" and shows time to first audio in a chart without an exact figure for 3.0, so the 0.81 comes from the independent leaderboard and not from xAI's text [1][6].

Why Smarter Can Mean Slower

The docs make the mechanism plausible even though they do not quantify it. grok-voice-3.0 has reasoning on by default [2]. A model that reasons before it speaks has to produce some internal computation before the first audio token, and that computation is a fixed cost paid at the start of each turn. Competing systems make the same bargain visibly: GPT-Live-1 (Astra, medium) takes 1.34 seconds and Gemini 3.8 Live Extended Thinking (High) takes 1.35 seconds, while the cheaper Gemini 3.8 Live without extended thinking responds in 1.18 seconds but scores only 30.1 percent on tau-Voice [6]. Across the table, the models that are better at agentic work are generally the ones that wait longer, and Grok Voice 3.0 is notable for sitting at the efficient end of that curve.

How Much Does 110 Milliseconds Matter

Human conversation has a gap between turns of a few hundred milliseconds, so a response near one second already feels slow, and a change from 0.70 to 0.81 seconds sits inside the zone where users notice hesitation but do not abandon the call. Where it hurts most is in short transactional exchanges such as confirming a digit or answering yes or no, because a fixed startup cost is a larger share of a short turn. Where it barely matters is in long answers that stream, since the first audio arrives and the rest follows in real time. If your agent mostly asks and confirms, test with reasoning.effort set to "none". If it reasons over policy before it acts, leave the default.

Mitigations That Do Not Require a Different Model

• Send a short audible acknowledgment before a slow tool call so silence never exceeds a second. In practice this means using force_message with a brief line, which the docs list as a conversation item type [2].
• Use turn_detection.idle_timeout_ms to re-engage a silent caller instead of letting a dead line run [2].
• Prefer server-side tools such as web_search, file_search, x_search, and mcp, which the docs say run automatically, over client round trips when both would work [2].
• Pick binary audio transport to cut base64 overhead on long calls [2].

Step 5: Building a Grok Voice 3.0 Client With Only Documented Fields

The fastest way to understand a realtime API is to wire up the smallest working loop: connect, configure the session, define a tool, handle a tool call, and read audio chunks. The client below uses only fields and events from xAI's voice agent documentation: the wss://api.x.ai/v1/realtime?model= endpoint, bearer authentication, session.update with instructions, voice, reasoning.effort, turn_detection, and tools, the function tool schema, and the documented tool-call flow [2]. One caveat on the user message: the docs say conversation.item.create can add a user message but the page does not print the item's exact shape, and xAI's launch post describes the API as compatible with the OpenAI Realtime API specification [10]. The text message in the snippet therefore follows the OpenAI Realtime item format on that basis [20], and you should confirm it against the live docs before shipping.

python
/code
# Minimal Grok Voice 3.0 realtime client.
# Uses only fields documented at docs.x.ai (voice-agent page): endpoint,
# bearer auth, session.update, function tool schema, and the tool-call flow.
# The user text item follows the OpenAI Realtime item format, which xAI says
# its API is compatible with; confirm it against the live docs before shipping.
# pip install websockets
import asyncio, json, os
import websockets

MODEL = "grok-voice-3.0"   # pinned; grok-voice-latest is an alias
URL = f"wss://api.x.ai/v1/realtime?model={MODEL}"

SESSION = {
    "type": "session.update",
    "session": {
        "instructions": "You are a concise order-status agent. Confirm the order number before looking it up.",
        "voice": "eve",
        "reasoning": {"effort": "high"},
        "turn_detection": {"type": "server_vad"},
        "tools": [{
            "type": "function",
            "name": "lookup_order",
            "description": "Look up the shipping status of an order by its number",
            "parameters": {
                "type": "object",
                "properties": {"order_number": {"type": "string", "description": "The order number the caller gave"}},
                "required": ["order_number"],
            },
        }],
    },
}

def lookup_order(order_number: str) -> dict:
    # Replace with your real backend call.
    return {"order_number": order_number, "status": "shipped", "eta_days": 2}

async def main():
    headers = {"Authorization": f"Bearer {os.environ['XAI_API_KEY']}"}
    async with websockets.connect(URL, additional_headers=headers) as ws:
        await ws.send(json.dumps(SESSION))
        await ws.send(json.dumps({
            "type": "conversation.item.create",
            "item": {"type": "message", "role": "user",
                     "content": [{"type": "input_text", "text": "Where is order A1042?"}]},
        }))
        await ws.send(json.dumps({"type": "response.create"}))

        async for raw in ws:
            event = json.loads(raw)
            kind = event.get("type")
            if kind == "response.output_audio.delta":
                audio_b64 = event["delta"]          # base64 PCM, 24 kHz by default
                print("audio chunk, base64 chars:", len(audio_b64))
            elif kind == "response.function_call_arguments.done":
                args = json.loads(event["arguments"])
                result = lookup_order(**args)
                await ws.send(json.dumps({
                    "type": "conversation.item.create",
                    "item": {"type": "function_call_output",
                             "call_id": event["call_id"],
                             "output": json.dumps(result)},
                }))
                await ws.send(json.dumps({"type": "response.create"}))
            elif kind == "response.done":
                print("turn finished")
                break
            elif kind == "error":
                print("error:", event)
                break

asyncio.run(main())

What the Client Does and Why

Pinning the model in the URL to grok-voice-3.0 is a deliberate choice that Step 7 explains. The session.update call sets reasoning to "high", uses server VAD so the server handles barge-in, and registers one function tool named lookup_order using the documented JSON schema shape: a type of "function", a name, a description, and parameters as a JSON Schema object [2]. When the server finishes assembling a tool call it emits response.function_call_arguments.done with the function name, call_id, and arguments. Your code runs the function, sends a conversation.item.create of type function_call_output carrying the call_id and the result as a JSON string, and then sends response.create to make the model speak the answer [2]. If the model issues parallel calls, you send every output first and then one response.create, and you wait for the current turn's audio to finish before sending that response request [2].

Testing the Connection From a Shell

Before you write any audio code, confirm that your key, network path, and model ID work from a terminal. The snippet below uses websocat, a command-line WebSocket client, to open the same endpoint, and a curl call to xAI's documented speech-to-text endpoint for a quick credential test [4].

bash
/code
#!/usr/bin/env bash
# Smoke-test credentials and the pinned model name from a terminal.
# Requires: websocat (https://github.com/vi/websocat) and curl.
set -euo pipefail
: "${XAI_API_KEY:?Set XAI_API_KEY first}"

# 1) Open the realtime socket, send one documented session.update, print events.
echo '{"type":"session.update","session":{"voice":"eve","instructions":"You are a helpful customer support agent.","turn_detection":{"type":"server_vad"}}}' \
  | websocat -H "Authorization: Bearer $XAI_API_KEY" \
      "wss://api.x.ai/v1/realtime?model=grok-voice-3.0" \
  | head -n 5
# Expect conversation.created, then session.updated echoing your settings.

# 2) Credential check against the documented speech-to-text endpoint.
curl -s https://api.x.ai/v1/stt \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -F model=grok-voice-transcribe-2.0 \
  -F file=@recording.mp3

# 3) Find hard-coded model names in your repo before the 2.0 deprecation bites.
grep -rnE "grok-voice-(2\.0|latest)" --include="*.py" --include="*.ts" --include="*.json" --include="*.env*" . || true

The Same Session as Plain JSON

Because the session configuration is just JSON, keep it in a file under version control and load it at startup. That makes prompt changes reviewable and lets you diff a change to instructions the same way you diff code. The structure below mirrors the documented fields, including the resumption, replace, and keyterm settings described in Step 1 [2].

json
/code
{
  "type": "session.update",
  "session": {
    "instructions": "You are a support agent for Acme Mobile. Keep answers under two sentences unless asked for detail.",
    "voice": "eve",
    "reasoning": { "effort": "high" },
    "turn_detection": { "type": "server_vad", "idle_timeout_ms": 8000 },
    "resumption": { "enabled": true },
    "audio": {
      "input": {
        "format": { "type": "audio/pcmu", "rate": 8000 },
        "transcription": {
          "language_hint": "es-MX",
          "keyterms": ["Acme Mobile", "eSIM", "prepaid"]
        }
      },
      "output": {
        "format": { "type": "audio/pcmu", "rate": 8000 },
        "transport": "binary",
        "speed": 1.0
      }
    },
    "replace": { "Acme": "Ack-mee" },
    "tools": [
      { "type": "web_search", "allowed_domains": ["acme.example.com"] },
      {
        "type": "function",
        "name": "lookup_order",
        "description": "Look up the shipping status of an order by its number",
        "parameters": {
          "type": "object",
          "properties": { "order_number": { "type": "string", "description": "The order number" } },
          "required": ["order_number"]
        }
      }
    ]
  }
}

Step 6: Cost Math Per Call

Grok Voice 3.0 is billed at $0.08 per minute, which is $4.80 per hour, and xAI's launch announcement for the Voice Agent API in December 2025 described billing as based on audio duration [5][10]. A flat per-minute rate makes budgeting easier than token billing, where the price of a call depends on how much the model talks, how long the context grows, and how much audio is cached.

Worked Examples

A five minute support call costs $0.40. A two minute reminder call costs $0.16. The Starlink figure of about 20,000 calls a day, if each call averaged four minutes, would be 80,000 minutes and $6,400 a day, and if 70 percent of those calls resolve without a human, the remaining 6,000 calls still need an agent, so the value of the model depends on what a human-handled call costs you and not only on the voice bill [1]. The average call length in that example is my assumption, not an xAI figure, because xAI has not published one.

Compare that with the benchmark-derived cost Artificial Analysis publishes. Its cost per hour of input audio, measured on a fixed 40-question Big Bench Audio subset and not a list price, is $4.80 for Grok Voice 3.0, $5.83 for GPT-Live-1 (Astra, medium), and $3.50 for Gemini 3.8 Live Extended Thinking (High) [6]. Gemini is cheaper per hour on that measure, which is a reminder that Grok's cost advantage is specific to the OpenAI comparison and not universal.

Tools and Extras Change the Bill

The flat rate covers the voice session, and tool calls are priced separately. The xAI model pricing page lists Speech to Speech at $0.08 per minute, with speech-to-text at $0.10 per hour for REST and $0.20 per hour for streaming, and text-to-speech at $15 per 1 million characters [5]. Secondary pricing write-ups also report separate charges for web search calls and for telephony when a phone number is attached, but I could not confirm those figures on xAI's own pages, so check the pricing page for the tools you enable before you forecast a budget. The cost calculator below makes those assumptions explicit parameters, with the one confirmed figure as the default.

python
/code
# Cost model for a Grok Voice 3.0 deployment.
# CONFIRMED on docs.x.ai pricing: speech to speech $0.08 per minute.
# Everything else is a parameter you set from your own contract and traffic.
from dataclasses import dataclass

VOICE_RATE_PER_MIN = 0.08          # grok-voice-3.0, same as 2.0

@dataclass
class Scenario:
    calls_per_day: int
    avg_minutes: float
    automation_rate: float          # share resolved with no human (Starlink reports ~0.70)
    human_cost_per_call: float      # your loaded cost of a human-handled call
    tool_cost_per_call: float = 0.0 # set from the pricing page for the tools you enable

def daily_cost(s: Scenario) -> dict:
    voice = s.calls_per_day * s.avg_minutes * VOICE_RATE_PER_MIN
    tools = s.calls_per_day * s.tool_cost_per_call
    escalated = s.calls_per_day * (1 - s.automation_rate)
    human = escalated * s.human_cost_per_call
    baseline = s.calls_per_day * s.human_cost_per_call
    total = voice + tools + human
    return {
        "voice_bill": round(voice, 2),
        "tool_bill": round(tools, 2),
        "human_handled_calls": round(escalated),
        "human_cost": round(human, 2),
        "total_with_agent": round(total, 2),
        "all_human_baseline": round(baseline, 2),
        "daily_saving": round(baseline - total, 2),
    }

if __name__ == "__main__":
    # Illustrative only: 20,000 calls, 4 minute average (an assumption, not an xAI figure),
    # 70% automation, $6.00 per human-handled call.
    print(daily_cost(Scenario(20_000, 4.0, 0.70, 6.00)))
    # Five minute single call:
    print("5 min call:", round(5 * VOICE_RATE_PER_MIN, 2))

Cascade Versus Speech-to-Speech Cost

A cascade bills three things at once: recognition minutes, language model tokens, and synthesized characters. Using the documented $0.20 per hour streaming recognition rate and $15 per million characters for synthesis, a minute of agent speech at roughly 900 characters (about 150 words per minute at six characters per word, my estimate) costs about $0.0135 for synthesis and about $0.0033 for recognition, leaving you to add the language model tokens for the turn [5]. That puts the non-LLM portion of a cascade near 1.7 cents per minute under these assumptions, so a cascade can be cheaper on paper if your language model is small, and the case for speech-to-speech rests on latency and conversational quality more than on price. Run the numbers with your own call profile before deciding.

Step 7: Migration Guide, Alias Versus Pinned Version

On October 14, grok-voice-latest began pointing to grok-voice-3.0, and any session that used the alias was upgraded without code changes [3]. That is convenient for a prototype and risky for production, because your agent's behavior changed overnight without a deploy, a code review, or a regression run.

Decide Which Model Name Belongs in Which Environment

• Development and staging: use grok-voice-latest, so you see model changes early.
• Production: pin grok-voice-3.0 in configuration, and upgrade deliberately after replaying your test conversations.
• Anything still on grok-voice-2.0: move it now, because xAI's release notes list 2.0 as deprecated, and the docs give no sunset date that I could find, so assume it can be removed [3][2].

Note that the xAI announcement page itself lists only grok-voice-latest as the model ID and does not give a separate versioned ID, while the API documentation and release notes do list grok-voice-3.0 [1][2][3]. Trust the docs for the pinned name, and confirm it by opening a session with it and checking session.updated.

A Practical Regression Plan

1. Export 30 to 50 real conversations, including your worst ones, as scripts with expected tool calls.
2. Replay them against 2.0 and 3.0 and record task success, tool-call correctness, and time to first audio on your network.
3. Compare reliability, not only the mean: run each script several times and count how many pass every time, the same idea behind pass^k in tau-bench [12].
4. Roll out to a small share of traffic first, with the model name in your logs so a regression can be traced to a version.
5. Keep the previous pinned model in your config for a fast rollback, as long as xAI still serves it.

The prompts themselves may also need attention. A model that reasons by default tends to follow long, nuanced instructions better, which means a prompt full of workarounds written for 2.0 may now over-constrain it. Trim defensive instructions one at a time and re-run the same scripts.

Step 8: How Grok Voice 3.0 Compares With GPT-Live, Gemini Live, and Others

The table below uses the Artificial Analysis leaderboard figures from October 2026 and adds the vendor-reported or documented details that matter for a build decision [6][1].

Reading the Comparison

Grok Voice 3.0 is the best all-round score and the fastest of the three top reasoning configurations, but it does not dominate. GPT-Live-1 (Astra, medium) is better on tau-Voice by 2.9 points, and OpenAI's smaller Sol configuration scores slightly higher on Full-Duplex-Bench. Gemini 3.8 Live Extended Thinking (High) is cheaper per audio hour on the benchmark-derived measure. If your workload is customer support with many tool calls, the tau-Voice gap is the number to test yourself. If it is conversational flow and speed, Grok has the stronger case. For how the OpenAI side works internally, including its delegation to a background reasoning model, see our deep dive on GPT-Live.

Different Approaches Worth Knowing

Speech-to-speech is not the only design for fast voice agents. Inception's Mercury Voice applies a diffusion language model to the reasoning step of a voice pipeline, which attacks the language model latency in a cascade instead of replacing the cascade, and we covered the trade-offs in our Mercury Voice explainer. Dedicated synthesis models, discussed in our ElevenLabs Eleven v4 post, lead on voice quality and expressive control. xAI's earlier text model line, covered in our Grok 4.7 explainer, is separate from the voice models, so a strong text benchmark for Grok does not transfer to Grok Voice.

Step 9: Production Architecture for a Grok Voice 3.0 Agent

A realtime voice agent is a distributed system with a human on the other end, and most failures come from the plumbing and not from the model. A sound layout has five parts.

1. Transport and Authentication

Never put your API key in a browser or mobile app. The docs say API keys are for server-side use only, and recommend ephemeral tokens for browsers and mobile; because browsers cannot set WebSocket headers, the token is passed as a subprotocol prefixed with xai-client-secret. [2]. For phone calls, run a server that bridges your telephony provider to the realtime socket, and choose audio/pcmu or audio/pcma at 8000 Hz to match the carrier so you do not transcode in the middle [2]. xAI publishes demo apps for a web agent, a Twilio phone agent, a WebRTC agent, and an iOS tester in its cookbook repository, which are good references for these patterns [4].

2. Audio Handling

The docs recommend roughly 100 ms chunks of 24 kHz PCM16 for buffered microphone audio [2]. Keep the capture loop and the send loop separate so a slow network write never stalls your microphone read. Switch to binary transport when you control both ends, because base64 inside JSON adds about a third more bytes to every audio frame. For interruptions, rely on server_vad barge-in, and when you must play a legally required disclosure the caller cannot talk over, use a force_message with interruptible: false, which drops caller audio until playback finishes [2].

3. Tool Design

The tool-call loop is where agent quality is made or lost. Keep function schemas narrow, with one clear purpose each and required parameters spelled out, so the model does not have to guess. Return compact JSON results, because every extra token the model reads aloud or reasons over costs time. Send the tool output and then response.create only after the current turn's audio has finished, as the docs require, and for parallel calls send all outputs before a single response.create [2]. Prefer server-side tools where they fit: file_search against a vector store for policy documents, web_search with allowed_domains limited to your own sites, and mcp for existing internal services [2]. For background on why tool design dominates agent reliability, our post on how LLM agents learn to use tools and the analysis in why 88 percent of AI agents fail apply directly to voice.

4. State, Reconnects, and Escalation

Enable resumption.enabled and store the conversation.id from conversation.created so a dropped connection can resume with ?conversation_id= and the server replays cached turns, within the 30 minute inactivity window [2]. Keep your own transcript and tool log as well, because the server cache is a convenience and not an audit record. Design the human handoff on day one. The Starlink figure of about 70 percent resolved without a human means about 30 percent do not, and those callers should reach a person with the full transcript and tool history already attached [8].

5. Observability and Evaluation

Log the time from the end of user speech to the first response.output_audio.delta for every turn, because that is your real time to first audio on your real network, and it will not match the 0.81 second leaderboard figure exactly. Record every tool call and its arguments, the model name from session.updated, and the transcript. Build a replay harness using the approach of tau-Voice and EVA-Bench: scripted callers, deterministic checks against the final database state, perturbations for accents and noise, and repeated trials [11][13]. A voice agent without this loop is a demo.

On compliance, the docs state that the platform is SOC 2 Type II, HIPAA eligible with a business associate agreement available, GDPR compliant with data processing agreements and EU data residency options, and that audio is processed in real time and not stored or used for training [4]. Confirm those terms in your own contract before sending regulated data.

Common Mistakes When Adopting Grok Voice 3.0

• Trusting the alias in production. The October 14 change moved every alias user at once, so the first time you learn about a model change should not be from a customer.
• Reading 86.9 as superiority on every axis. The index averages four tests, and the strongest competitor still leads on tau-Voice [6].
• Ignoring reliability. A benchmark pass rate is a single-run average, while a customer needs the call to work every time, which is what pass^k and EVA-Bench's pass@k family try to capture [12][13].
• Assuming the leaderboard latency applies to you. Network path, audio format, tool round trips, and reasoning effort all change your measured time to first audio.
• Sending the tool result and the next response request too early, which the docs say should wait for the current turn's audio to finish [2].
• Skipping pronunciation work. Brand names, product codes, and street names are where voice agents sound wrong, and the replace map and keyterms list exist for exactly that [2].
• Leaving reasoning on for trivial lines. If a greeting or a yes or no confirmation does not need deliberation, test reasoning.effort set to "none" and measure.
• Treating vendor deployment numbers as audited. The 20,000 daily calls and the 70 percent resolution rate at Starlink come from xAI [1].

What This Means for Creators Using Miraflow

Most creators will not open a realtime WebSocket this month, but voice quality and voice control already shape the videos they publish. A Short with a flat, robotic narration loses viewers in the first seconds, and the same models that power voice agents are what make narration sound conversational. When you build a faceless channel with Miraflow's Text2Shorts, you choose a voice and a speed for the generated script, and the walkthrough in our post on going from prompt to reel with Text2Shorts shows that workflow end to end. If you are writing the scripts first, the templates in our YouTube Shorts script prompts pair well with any narration voice.

Speech-to-speech models also point to where creator tools are heading: live co-hosts that react to chat, interactive tutorials that answer questions in your cloned voice, and hands-free editing by voice. If you are weighing a cloned voice for your own channel, read our guide to AI voice cloning for content creators first. Sound is more than speech as well, and Miraflow's AI music generator covers the bed track under your narration, while AI Clipping turns a long recording of a voice session or podcast into captioned vertical clips. You can start from the Miraflow home page and move between those tools in one browser tab.

Conclusion

Grok Voice 3.0 is a meaningful upgrade in the area that decides whether a voice agent is useful: finishing multi-step tasks. A 15.1 point gain on tau-Voice, first place on the Artificial Analysis index at 86.9, and an unchanged $0.08 per minute make it a strong default for new builds, and its 0.81 second time to first audio is still well ahead of the other top reasoning configurations. The caveats are real as well: it trails GPT-Live-1 on tau-Voice, it is slower to first audio than Grok Voice 2.0, the deployment numbers come from xAI, and the automatic alias migration means production teams should pin grok-voice-3.0 and test before they trust it.

The practical path is short. Pin the model, replay your own conversations against 2.0 and 3.0, log your real time to first audio, keep a human handoff, and let your own numbers decide whether the benchmark gains show up in your calls. Voice agents are moving fast, and the teams that win will be the ones that measure their own agents as carefully as the leaderboards measure the models.

Frequently Asked Questions

What is Grok Voice 3.0?

Grok Voice 3.0 is xAI's speech-to-speech model in its Voice Agent API, released on October 14, 2026. It takes spoken audio in and returns spoken audio out, supports tool calls, and is available through a WebSocket realtime endpoint with the model ID grok-voice-3.0 [1][2].

How much does Grok Voice 3.0 cost?

It costs $0.08 per minute, or $4.80 per hour, the same as Grok Voice 2.0 [5][3]. A five minute call is $0.40 for the voice session, with any separately billed tools on top.

Is Grok Voice 3.0 really number one?

It ranks first on the Artificial Analysis Speech-to-Speech Index with 86.9, ahead of GPT-Live-1 (Astra, medium) at 83.2 and Gemini 3.8 Live Extended Thinking (High) at 82.6 [6]. It does not lead every component, because GPT-Live-1 scores 74.5 percent on tau-Voice against 71.6 percent for Grok [6].

Why is Grok Voice 3.0 slower than 2.0?

Artificial Analysis lists 0.81 seconds time to first audio for 3.0 and 0.70 seconds for 2.0 [6]. The docs say 3.0 reasons by default, which plausibly accounts for the extra delay, but xAI does not publish the cause or the trade-off between reasoning settings [2].

Do I have to change my code to use Grok Voice 3.0?

No, if you use grok-voice-latest, because it now points to 3.0 and the endpoint, parameters, and events are unchanged [3]. If you hard-coded grok-voice-2.0, change the model field, since 2.0 is deprecated.

Should I pin the model or use the latest alias?

Pin grok-voice-3.0 in production and use the alias in development, so you control when behavior changes. Replay your own test conversations before each upgrade.

Does Grok Voice 3.0 support function calling?

Yes. The docs list function tools alongside file_search, web_search, x_search, and mcp, and describe the flow of a response.function_call_arguments.done event, a function_call_output item, and a response.create [2].

Is the API compatible with the OpenAI Realtime API?

xAI's December 2025 launch post describes it as compatible with the OpenAI Realtime API specification, but the current docs list unsupported events such as rate_limits.updated, so verify each event you depend on [10][2].

Can I use Grok Voice 3.0 in a browser?

Yes, with ephemeral tokens passed as a WebSocket subprotocol prefixed with xai-client-secret., never with a raw API key [2].

Which audio formats does it support?

The docs list audio/pcm at 8 to 48 kHz (24 kHz default), audio/pcmu and audio/pcma at 8 kHz, and audio/opus at 24 kHz, with input and output formats allowed to differ [2].

Are the Starlink and Tesla numbers independently verified?

No. The 20,000 daily calls, 70 percent resolved without a human, and Tesla usage figures are reported by xAI in its announcement [1].

Will voice models like this change how creators make videos?

Gradually. Today the benefit shows up as more natural narration and voice control in tools such as Text2Shorts, and over time as interactive and live formats that respond to an audience.

References

[1] xAI. "Grok Voice 3.0."

[2] xAI. "Speech to Speech (Voice Agent) API, Grok API Documentation."

[3] xAI. "Release Notes, Grok API Documentation."

[4] xAI. "Voice Overview, Grok API Documentation."

[5] xAI. "Models and Pricing, Grok API Documentation."

[6] Artificial Analysis. "Speech to Speech AI Model and Provider Leaderboard."

[7] Artificial Analysis. "Speech to Speech Benchmarking Methodology."

[8] SiliconANGLE. "Grok Voice 3.0 from SpaceXSI outscores OpenAI and Google on speech-to-speech index."

[9] Unite.AI. "xAI Introduces Grok Voice 3.0 Speech-to-Speech Model for Voice Agents."

[10] xAI. "Bringing the power of Grok Voice to all developers (Voice Agent API launch, December 17, 2025)."

[11] Ray, Dhandhania, Barres, Narasimhan. "tau-Voice: Benchmarking Full-Duplex Voice Agents on Real-World Domains."

[12] Yao et al.. "tau-bench: A Benchmark for Tool-Agent-User Interaction in Real-World Domains."

[13] ServiceNow. "EVA-Bench: A New End-to-End Framework for Evaluating Voice Agents."

[14] Lin et al.. "Full-Duplex-Bench: A Benchmark to Evaluate Full-duplex Spoken Dialogue Models on Turn-taking Capabilities."

[15] Defossez et al., Kyutai. "Moshi: a speech-text foundation model for real-time dialogue."

[16] OpenAI. "Hello GPT-4o."

[17] Radford et al., OpenAI. "Robust Speech Recognition via Large-Scale Weak Supervision (Whisper)."

[18] Borsos et al., Google. "AudioLM: a Language Modeling Approach to Audio Generation."

[19] Fang et al.. "LLaMA-Omni: Seamless Speech Interaction with Large Language Models."

[20] OpenAI. "Realtime conversations, Realtime API guide."

[21] Suzgun et al.. "Challenging BIG-Bench Tasks and Whether Chain-of-Thought Can Solve Them."

[22] Artificial Analysis. "Speech Reasoning Benchmarking Methodology (Big Bench Audio)."

[23] Xie and Wu. "Mini-Omni: Language Models Can Hear, Talk While Thinking in Streaming."