¿Es Grok 4.6 el mejor modelo para programar? Editor sí, terminal no
DominicodexAI publicó Grok 4.6 el 12 de agosto de 2026, treinta y cinco días después de Grok 4.5.
Y como pasa siempre, en cuestión de horas ya circulaban capturas de tablas de barras diciendo que es el mejor modelo del mundo para programar.
La pregunta está mal formulada.
No porque Grok 4.6 sea malo —no lo es, y en una de las dos medidas que importan está arriba— sino porque "programar" no es una sola tarea, y los benchmarks que la miden no puntúan lo mismo.
Hay dos cifras públicas de Grok 4.6 que responden a la pregunta mejor que cualquier hilo de X. Una la publica xAI. La otra la mide un tercero. Y entre las dos hay una brecha que te dice exactamente cuándo te conviene este modelo y cuándo no.
Vamos con las dos.
Qué ha publicado xAI y qué ha medido alguien más
Antes de mirar un solo número, la distinción de siempre: no es lo mismo una cifra que publica el fabricante en su propia nota de prensa que una cifra medida por un tercero con un harness que no controla el fabricante.
Las dos sirven. Pero no valen igual, y mezclarlas en la misma tabla es la forma más común de sacar una conclusión equivocada. Si quieres el criterio completo para separarlas, lo desarrollé al analizar las cifras de Grok 4.5, Fable 5 y DeepSeek V4, y el caso más descarado de tabla propia puntuando a los rivales lo tienes en la tabla de Alibaba para Qwen3.8-Max.
Con Grok 4.6, esto es lo que hay a 24 de agosto de 2026.
Autoreportado por xAI (su propia nota de lanzamiento):
| Benchmark | Grok 4.6 | Qué mide |
|---|---|---|
| CursorBench v3.2 | 69,9 % | Edición de código dentro del editor |
| DeepSWE v1.1 | 65,9 % | Ingeniería de software autónoma |
| FrontierCode v1.1 | 61,3 % | Código de dificultad alta |
| APEX-Agents | 57,5 % | Tareas agénticas de horizonte largo |
| APEX-SWE | 56,4 % | Ingeniería de software agéntica |
| Terminal-Bench v3.0 | 26 % | Trabajo real en terminal |
Medido por terceros:
- Artificial Analysis Intelligence Index: 61. Verificado de forma independiente.
- Terminal-Bench 3.0: 26,5 % en el snapshot público del leaderboard, actualizado el 20 de agosto de 2026 (el benchmark lo desarrolla el equipo de Harbor junto a Laude Institute, Snorkel AI y Turing).
Fíjate en que la última fila de la tabla de xAI y la medición externa coinciden: 26 % frente a 26,5 %. Aquí no hay discusión metodológica ni harness sospechoso. xAI reporta su peor número con honestidad, y el tercero lo confirma.
Ese es el número del que nadie hizo captura.
La brecha: 69,9 % en el editor, 26,5 % en la terminal
Pon las dos medidas juntas y el modelo se parte en dos.
Grok 4.6, dos medidas del mismo modelo
Editor (CursorBench v3.2) 69,9 %
████████████████████████
Terminal (Terminal-Bench 3.0) 26,5 %
█████████
El mismo modelo, la misma semana, con 43 puntos de diferencia según lo que le pidas.
Y para saber si ese 26,5 % es bueno o malo hace falta el contexto del leaderboard completo. Esta es la foto de Terminal-Bench 3.0 al 20 de agosto de 2026:
| # | Modelo | Terminal-Bench 3.0 |
|---|---|---|
| 1 | Claude Opus 5 | 42,7 % |
| 2 | GPT-5.6 Sol | 34,6 % |
| 3 | Claude Fable 5 | 34,0 % |
| 4 | GLM-5.3 | 32,4 % |
| 5 | Grok 4.6 | 26,5 % |
| 6 | Claude Opus 4.8 | 21,1 % |
| 7 | GPT-5.6 Terra | 20,8 % |
| 8 | SWE-1.7 Lightning | 18,6 % |
| 9 | Grok 4.5 | 15,7 % |
| 10 | Claude Sonnet 5 | 14,6 % |
| 11 | GPT-5.6 Luna | 14,3 % |
| 12 | GLM-5.2 | 4,6 % |
Dos lecturas, y las dos son verdad.
La mala: Grok 4.6 queda quinto, a 16,2 puntos de Claude Opus 5. En trabajo de terminal saca el 62 % de la puntuación del líder. No está cerca.
La buena, y es la que casi nadie contó: Grok 4.5 estaba en 15,7 %. Grok 4.6 está en 26,5 %. Son 10,8 puntos de salto en treinta y cinco días, el mayor avance generacional de toda la tabla. De paso, Grok 4.6 ya pasa por delante de Claude Opus 4.8 (21,1 %) y de GPT-5.6 Terra (20,8 %).
xAI lo respalda con su propia medición en la misma dirección: APEX-Agents sube de 47,1 % en Grok 4.5 a 57,5 % en 4.6, otros 10,4 puntos.
Es decir: el trabajo agéntico es exactamente donde xAI ha metido el esfuerzo de esta versión, y se nota. Simplemente partían muy por detrás y todavía no han llegado.
Por qué el editor y la terminal no miden lo mismo
Esta es la parte que convierte una tabla en una decisión.
Un benchmark de edición en el editor te pone delante un cambio acotado: aquí está el archivo, aquí está el contexto, escribe el diff. Una o pocas pasadas. El estado del mundo no cambia mientras trabajas. Si el modelo razona bien y conoce el lenguaje, acierta.
Un benchmark de terminal es otro deporte:
EDITOR TERMINAL
───────── ────────
contexto dado hay que descubrirlo
1 pasada decenas de pasos
estado fijo estado que tú mutas
fallo = diff malo fallo = entorno roto
En la terminal el modelo tiene que decidir qué comando lanzar, leer una salida que no esperaba, entender que algo ha cambiado por su propia acción anterior y corregir el rumbo sin perder el objetivo. Terminal-Bench 3.0 aprieta justo ahí: incluye nodos con GPU, topologías multi-contenedor, microservicios vivos y una corrección estricta que solo da el punto si el resultado final es exactamente el pedido.
Ahí no se premia saber programar. Se premia no perder el hilo durante cuarenta pasos y verificar tu propio trabajo antes de seguir. xAI lo reconoce en su nota: dicen que en trayectorias largas empezaron a ver al modelo autoverificándose más.
Que un modelo se caiga de 69,9 % a 26,5 % entre esos dos escenarios no es una contradicción. Es la descripción de dónde está su límite. Y si tú operas agentes que leen, escriben y ejecutan tests sobre tu repositorio, el número que te afecta es el segundo, no el primero.
Por qué un bucle agéntico largo es tan frágil, y qué controles hay que ponerle, lo desmenucé en el agentic loop en producción con TypeScript.
Lo que cuesta
Grok 4.6 en la API de xAI, tarifa estándar por millón de tokens:
| Entrada | Entrada en caché | Salida | |
|---|---|---|---|
| Grok 4.6 | $2 | $0,50 | $6 |
| Claude Opus 5 | $5 | — | $25 |
Ventana de contexto: 500K tokens.
Y el detalle que se come presupuestos: a partir de 200K tokens de prompt, la petición entera pasa a la banda de contexto largo. No se encarece solo el tramo que excede el umbral: se recalculan todos los tokens de esa petición a la tarifa alta. Es el mismo mecanismo que ya tenía Grok 4.5 y que expliqué con números en el análisis de Grok 4.5. Si tu agente arrastra contexto acumulado, cruzas ese umbral sin darte cuenta.
Ahora, la comparación honesta. Grok 4.6 cuesta 2,5 veces menos en entrada y 4,2 veces menos en salida que Opus 5. Si divides el precio de salida entre los puntos de Terminal-Bench que consigue cada uno, sale esto:
- Grok 4.6: $6 / 26,5 = $0,23 por punto
- Claude Opus 5: $25 / 42,7 = $0,59 por punto
Grok 4.6 rinde 2,6 veces más barato por punto de terminal. Esa cifra la he derivado yo de las dos tablas de arriba, no la publica nadie, y tiene una trampa importante: en trabajo agéntico, el modelo que falla es el más caro de todos, porque cada intento fallido se paga entero y además te consume el tiempo de revisión. El precio por punto es una buena guía para elegir modelo en tareas que puedes verificar barato, y una guía pésima para elegirlo en tareas que se rompen caro.
Ese cálculo, hecho por tarea completada y no por token, es el que decide de verdad, y lo desarrollé en el coste de los subagentes al cambiar de modelo.
Entonces, ¿es el mejor modelo para programar?
Con los datos públicos a 24 de agosto de 2026:
Sí, es una opción muy competitiva para:
- Escribir y editar código dentro del editor, con el contexto ya delante.
- Algoritmos, refactors acotados, scripts aislados y consultas complejas.
- Volumen alto de tareas verificables donde el precio por token pesa y un fallo se detecta en segundos.
- Contextos grandes de lectura, siempre que vigiles el umbral de 200K.
No, no lidera para:
- Agentes autónomos que corren durante decenas de pasos sobre tu repositorio.
- Trabajo de terminal con estado mutable: contenedores, servicios, migraciones.
- Cualquier flujo donde el coste de un fallo silencioso sea alto.
Y esta es la conclusión incómoda para los titulares: Grok 4.6 no compite con Claude Opus 5 en la fila que más importa si tu trabajo es agéntico, pero ha recortado más distancia en un mes que ningún otro modelo de la tabla. Si xAI mantiene ese ritmo, la comparación de dentro de dos versiones puede ser otra.
Para decidir modelo por tipo de trabajo en lugar de por titular, tengo el marco completo en Opus 5 vs GPT-5.6 vs Kimi K3.
Cómo comprobarlo en tu proyecto en una tarde
Ningún leaderboard puntúa tu repositorio. Esto sí:
- Coge tres tareas reales ya resueltas de tu historial de Git, con su diff final conocido. Una acotada de editor, una de refactor medio y una que toque terminal o migraciones.
- Lánzalas al mismo harness, cambiando solo el modelo. El harness pesa tanto como el modelo: si cambias las dos cosas a la vez, no estás midiendo nada.
- Puntúa por tarea completada, no por impresión. Pasó los tests o no pasó. Y anota el coste total de cada intento, fallos incluidos.
Con nueve ejecuciones tienes más información sobre tu caso que con todos los benchmarks de este post.
Y la parte que no cambia sea cual sea el modelo: si el requerimiento es ambiguo, fallan todos. Cuando cierras el alcance y las interfaces en un spec.md antes de ejecutar, cualquier modelo de frontera sube su tasa de acierto. Tienes la metodología completa en el libro de Spec-Driven Development, y el pipeline práctico con herramientas CLI agénticas en el curso Construye con IA: de la idea al producto con Claude Code.
En Dominicode Labs vamos pasando cada modelo nuevo por proyectos reales y compartimos los resultados: qué entra en el stack, qué se queda fuera y por qué.
Prueba Grok 4.6. Pero mide la fila que se corresponde con tu trabajo, no la que mejor queda en una captura.
Preguntas frecuentes
¿Cuánto ha mejorado Grok 4.6 respecto a Grok 4.5 en trabajo de terminal?
Ha subido de 15,7 % a 26,5 % en Terminal-Bench 3.0, según el snapshot público del leaderboard del 20 de agosto de 2026. Son 10,8 puntos en treinta y cinco días, el mayor salto generacional de la tabla. xAI reporta una mejora en la misma dirección con su propia medición de APEX-Agents: de 47,1 % a 57,5 %.
¿Por qué Grok 4.6 saca 69,9 % en CursorBench y solo 26,5 % en Terminal-Bench 3.0?
Porque miden trabajos distintos. CursorBench evalúa edición de código con el contexto ya dado y en pocas pasadas. Terminal-Bench 3.0 evalúa trayectorias largas en un entorno con estado mutable —contenedores, servicios vivos, nodos con GPU— y solo concede el punto si el resultado final es exactamente el pedido. El primer escenario premia saber programar; el segundo, no perder el hilo durante decenas de pasos.
¿El contexto de 500K de Grok 4.6 cambia algo para trabajar sobre un repositorio grande?
Ayuda a leer, pero ojo con la factura: a partir de 200K tokens de prompt, xAI recalcula todos los tokens de esa petición a la tarifa de contexto largo, no solo el exceso. Un agente que acumula contexto cruza ese umbral sin avisar. Y una ventana grande no arregla el problema de fondo del trabajo agéntico, que es mantener el objetivo, no almacenar texto.
¿Qué es APEX-Agents y por qué xAI lo destaca?
Es un benchmark de tareas agénticas de horizonte largo, y xAI lo destaca porque es donde más ha mejorado: 57,5 % frente al 47,1 % de Grok 4.5. Es una cifra autoreportada por xAI, no verificada por un tercero, así que conviene leerla como una señal de la dirección del trabajo del proveedor y no como una medición neutral.
¿Cuándo me conviene Grok 4.6 en lugar de Claude Opus 5?
Cuando tu trabajo sea acotado y verificable barato: edición en el editor, algoritmos, refactors pequeños, volumen alto de tareas que fallan de forma visible. Ahí el precio marca la diferencia, porque Grok 4.6 cuesta $2/$6 por millón frente a $5/$25 de Opus 5. Si tu trabajo es un agente autónomo corriendo sobre tu repositorio, los 16,2 puntos de diferencia en Terminal-Bench se pagan en fallos silenciosos y en tu tiempo de revisión, y ahí sale más caro lo barato.
¿Te resultó útil este artículo?
Compártelo con tu comunidad y ayuda a otros desarrolladores.