Grok Voice 3.0: Crea un Agente Speech-to-Speech (y Cuándo No Hacerlo)

1. Los hechos del lanzamiento

El anuncio de xAI llama a Grok Voice 3.0 “el modelo speech-to-speech más inteligente del mundo”, lo cual es posicionamiento, no evidencia. Lo concreto: un solo modelo que recibe audio y devuelve audio por WebSocket, con detección de voz del lado del servidor, tool calling, 20 códigos de idioma listados y facturación por minuto de conversación.

El lanzamiento de Microsoft del 1 de octubre tiene otra forma: MAI-Transcribe-2-Streaming (voz a texto), MAI-Voice-2.1 y MAI-Voice-2.1-Flash (texto a voz). Ninguno es un modelo speech-to-speech, así que son piezas para la ruta STT → LLM → TTS. Microsoft Learn etiqueta el modelo de transcripción en streaming como public preview sin SLA.

2. Qué mejoró vs Grok Voice 2.0

El post de xAI compara 3.0 con 2.0 usando números recolectados por Artificial Analysis el 13 de octubre de 2026. El Speech-to-Speech Index sube de 81.3 a 86.9, Big Bench Audio (razonamiento de voz) de 97.2% a 98.5%, y el Elo de Speech Agent Arena de 1011 a 1070. El éxito de tareas casi no se mueve: 94.6% a 94.8%.

Los saltos que importan para agentes están en la mecánica de la conversación. Full Duplex Bench, que prueba pausas, turnos e interrupciones, pasa de 95.1% a 97.0%. τ-Voice, escenarios de llamadas de soporte con acentos, ruido de fondo e interrupciones, pasa de 56.5% a 71.6%. El precio quedó igual, así que en el papel es un upgrade gratis.

3. Evidencia, y quién la midió

A diferencia de muchos posts de lanzamiento, los números principales acá no son xAI calificándose a sí misma: vienen de Artificial Analysis, un sitio de benchmarking independiente con un leaderboard público. Lo que sí eligió xAI es el set de comparación y las métricas que destaca, así que leí el leaderboard fila por fila el 14 de octubre para ver el cuadro completo.

Grok Voice 3.0 lidera el Index y el tiempo al primer audio en esa tabla, pero no gana todas las columnas: GPT-Live-1 (Astra, medium) puntúa más en τ-Voice, Gemini 3.8 Live tiene el Elo de Arena más alto de los cinco, y GPT-Live-1 (Sol, low) lo supera por poco en Full Duplex Bench.

4. ¿Speech-to-speech o STT → LLM → TTS?

Un modelo speech-to-speech escucha y habla en un solo paso, así que turnos, interrupciones y prosodia viven dentro del modelo. Un pipeline encadena tres servicios (transcribir, pensar, sintetizar) y el pegamento es tuyo: detección de voz, barge-in, buffering y el texto del medio.

Ese texto del medio es el verdadero trade-off. Con un pipeline podés loguearlo, redactarlo, pasarle guardrails y cambiar el LLM cuando aparezca uno más barato. Con speech-to-speech escribís menos orquestación y, según Artificial Analysis, tenés un primer audio rápido, pero hay menos para inspeccionar salvo que actives los eventos de transcripción.

Cómo elegiría yo

5. Quickstart: un cliente mínimo

Todo lo que sigue está adaptado de los docs de voz de xAI y verificado contra ellos el 2026-10-14. No lo corrí con una key real: tomalo como un smoke test de texto-entra, audio-sale que podés extender con un micrófono.

Instalá el paquete websockets, exportá XAI_API_KEY, corré el script y abrí reply.wav. El audio es PCM linear16 a 24 kHz; asumo mono porque los docs no indican la cantidad de canales.

import asyncio
import base64
import json
import os
import wave

import websockets

URL = "wss://api.x.ai/v1/realtime?model=grok-voice-latest"
HEADERS = {"Authorization": f"Bearer {os.environ['XAI_API_KEY']}"}


async def main():
    async with websockets.connect(URL, additional_headers=HEADERS) as ws:
        await ws.send(json.dumps({
            "type": "session.update",
            "session": {
                "voice": "eve",
                "instructions": "You are a helpful customer support agent.",
                "turn_detection": {"type": "server_vad"},
                "audio": {
                    "input": {"format": {"type": "audio/pcm", "rate": 24000}},
                    "output": {"format": {"type": "audio/pcm", "rate": 24000}},
                },
            },
        }))
        await ws.send(json.dumps({
            "type": "conversation.item.create",
            "item": {
                "type": "message",
                "role": "user",
                "content": [{"type": "input_text", "text": "Hello!"}],
            },
        }))
        await ws.send(json.dumps({"type": "response.create"}))

        pcm = bytearray()
        async for message in ws:
            event = json.loads(message)
            if event["type"] == "response.output_audio.delta":
                pcm += base64.b64decode(event["delta"])
            elif event["type"] == "response.done":
                break

    with wave.open("reply.wav", "wb") as f:
        f.setnchannels(1)   # mono (assumed, not stated in the docs)
        f.setsampwidth(2)   # 16-bit linear PCM
        f.setframerate(24000)
        f.writeframes(bytes(pcm))


asyncio.run(main())

# 1) microphone -> model (with server_vad, append is the only audio event you need)
async def send_audio(ws, chunks):  # chunks: raw PCM16 at 24 kHz
    async for chunk in chunks:
        await ws.send(json.dumps({
            "type": "input_audio_buffer.append",
            "audio": base64.b64encode(chunk).decode(),
        }))

# 2) a function tool, declared inside session.update -> session.tools
tools = [{
    "type": "function",
    "name": "get_order_status",
    "description": "Look up an order by id.",
    "parameters": {
        "type": "object",
        "properties": {"order_id": {"type": "string"}},
        "required": ["order_id"],
    },
}]

# 3) when the model calls it, return the output, then ask for the spoken reply
if event["type"] == "response.function_call_arguments.done":
    result = lookup_order(**json.loads(event["arguments"]))  # your code
    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"}))

# server: mint a short-lived token (never ship XAI_API_KEY to the client)
curl -X POST https://api.x.ai/v1/realtime/client_secrets \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"expires_after": {"seconds": 300}}'

// browser: pass the token as a WebSocket subprotocol
const ws = new WebSocket("wss://api.x.ai/v1/realtime",
  ["xai-client-secret." + token]);

{
  "type": "session.update",
  "session": {
    "input_audio_transcription": {"model": "mai-transcribe-2-streaming"},
    "modalities": ["text", "audio"],
    "instructions": "You are a helpful assistant.",
    "voice": {"name": "en-US-Harper:MAI-Voice-2-Flash", "type": "azure-standard"},
    "turn_detection": {"type": "azure_semantic_vad_multilingual"}
  }
}

6. Límites honestos y qué hacer esta semana

Veredicto

Grok Voice 3.0 es un upgrade creíble: los mismos $0.08 por minuto, mejor mecánica de conversación en un leaderboard independiente, y un protocolo lo bastante simple como para hacer un smoke test en unas 50 líneas de Python. No es la ruta más barata por minuto, y no gana todas las columnas de benchmark.

Mi regla: prototipá con speech-to-speech porque te lleva a una conversación funcionando en una tarde, y después cotizá un pipeline cuando conozcas tus caracteres y tokens por minuto reales. Si necesitás control a nivel de texto o el minuto más barato, los componentes MAI de Microsoft valen una mirada apenas salgan de preview.