Gemini 4 Argon: prueba de programación con 8 tareas y pruebas ocultas

Pusimos a Gemini 4 Argon y a Claude Opus 5.5 ante las mismas ocho tareas, con una sola llamada por tarea y pruebas ocultas que ninguno de los dos podía ver. En Python 3.14 los dos pasaron las 105 comprobaciones. Argon tardó 139.6 segundos en total frente a los 57.2 de Opus 5.5, y costó $0.042 frente a $0.112 con el precio de lista de cada proveedor.

Son ocho tareas con una sola ejecución cada una, así que conviene leerlo como comportamiento real. En corrección los dos empataron. Las diferencias están en el tiempo, en el costo y en una respuesta que necesita un Python más nuevo. Google ofrece Argon como disponibilidad general desde el 13 de octubre de 2026, y su precio de introducción de $2 por millón de tokens de entrada y $10 por millón de salida se mantiene hasta el 30 de noviembre; desde el 1 de diciembre se duplica a $4 y $20 (página de precios de Google, consultada el 4 de noviembre de 2026).

Cómo lo probamos

El 4 de noviembre de 2026 enviamos cada tarea a gemini-4-argon y a claude-opus-5-5, con una llamada por tarea y por modelo, sin prompt de sistema y sin ajuste de razonamiento. Los dos corrieron en su nivel por defecto: medium para Argon (documentación de thinking de Google, consultada el 4 de noviembre de 2026) y medium para Opus 5.5 (documentación de effort de Anthropic, el mismo día). Cada tarea produjo una respuesta puntuable por modelo.

El tiempo es la latencia que cada proveedor informa en cada llamada, sumada; deja fuera nuestras ejecuciones de puntuación. El costo aplica el precio de lista de cada proveedor a los tokens que devolvió la API. OmniaKey también vende los dos modelos, así que ejecutamos la prueba a través de él con una sola clave; cada precio de aquí es la tarifa de Google o de Anthropic.

Un script extrajo el bloque de código de cada respuesta y lo ejecutó contra un archivo unittest oculto que ningún modelo vio, en un proceso de Python aislado y con tiempo límite. La primera pasada usó el Python 3.9.6 del sistema; después volvimos a puntuar las mismas respuestas guardadas en Python 3.14.3, sin llamadas nuevas y sin costo adicional.

Las ocho tareas

Las ocho son trabajos pequeños de Python de los que aparecen en un día normal: una corrección de error, dos clases pequeñas, un refactor, un analizador, un formateador de duraciones, un asistente de agenda y una búsqueda en grafo. Cada enunciado describía el comportamiento pedido en prosa llana y ninguno incluía las pruebas.

Tarea 1: arreglar un error al fusionar intervalos

merge_intervals ordenaba y fusionaba rangos, pero dejaba separados los pares que se tocan, como (1, 3) y (3, 5). Una comparación lo arregla.

• Gemini 4 Argon (5.6 s): 12 de 12.
• Claude Opus 5.5 (2.9 s): 12 de 12.

Veredicto: empate en comprobaciones. Opus respondió en la mitad del tiempo.

Tarea 2: un limitador de tasa con cubo de tokens

TokenBucket(rate_per_second, capacity) tenía que recargar de forma continua, no pasar de la capacidad y aguantar valores de now que retroceden.

• Gemini 4 Argon (6.6 s): 10 de 10.
• Claude Opus 5.5 (4.8 s): 10 de 10.

Veredicto: empate. Los dos manejaron el reloj hacia atrás.

Tarea 3: una caché LRU con contadores de aciertos y fallos

LRUCache necesitaba orden de expulsión, actualización en el sitio, conteos en stats() y una lista de claves de la menos usada a la más reciente.

• Gemini 4 Argon (7.1 s): 10 de 10.
• Claude Opus 5.5 (4.1 s): 10 de 10.

Veredicto: empate. Opus fue 3 s más rápido.

Tarea 4: refactorizar sin cambiar el comportamiento

El módulo funcionaba. La respuesta debía conservar slugify y slug_counts y comportarse igual con letras Unicode, puntuación y separadores repetidos.

• Gemini 4 Argon (15.9 s): 12 de 12.
• Claude Opus 5.5 (8.7 s): 12 de 12.

Veredicto: empate. Los dos conservaron todos los casos fijados.

Tarea 5: convertir una línea de log en un dict

Un analizador de key=value con valores entre comillas, comillas escapadas y barras invertidas, marca de tiempo UTC, y ValueError para claves duplicadas, un key= vacío y basura.

• Gemini 4 Argon (16.1 s): 13 de 13.
• Claude Opus 5.5 (10.9 s): 13 de 13.

Veredicto: empate. Los dos acertaron el escapado al primer intento.

Tarea 6: formatear y analizar duraciones

format_duration y parse_duration debían redondear la mitad alejándose de cero, quitar partes vacías (3601 queda en 1h1s), rechazar formas inválidas y hacer ida y vuelta con todos los valores. Los días no se imprimen: 90000 queda en 25h.

• Gemini 4 Argon (60.9 s): 0 de 14 en Python 3.9, 14 de 14 en 3.14.
• Claude Opus 5.5 (14.0 s): 14 de 14 en las dos.

Veredicto: empate en 3.14. En 3.9 la respuesta de Argon ni siquiera se importó; lo cuento en la sección siguiente.

Tarea 7: huecos libres de salas de reuniones

free_slots debía recortar las reservas a la jornada laboral, fusionar las que se tocan, descartar huecos de menos de 15 minutos y rechazar entradas inválidas.

• Gemini 4 Argon (18.9 s): 17 de 17.
• Claude Opus 5.5 (5.0 s): 17 de 17.

Veredicto: empate en comprobaciones. Argon tardó casi cuatro veces más.

Tarea 8: camino más corto con desempate

shortest_path necesitaba Dijkstra con el camino lexicográficamente menor entre los de igual longitud, además de aristas paralelas, bucles y el caso sin camino.

• Gemini 4 Argon (8.5 s): 17 de 17.
• Claude Opus 5.5 (6.8 s): 17 de 17.

Veredicto: empate. El más ajustado de los ocho.

Resultados: aciertos, tiempo y costo

En Python 3.14 los dos modelos pasaron las 105 comprobaciones. En Python 3.9.6 Argon pasó 91, porque una respuesta no se pudo importar.

Opus 5.5 respondió más rápido en todas las tareas. La brecha más corta fue la del grafo (8.5 s frente a 6.8 s) y la más ancha la de duraciones (60.9 s frente a 14.0 s).

Con el precio de lista, las ocho tareas costaron $0.042 en Argon y $0.112 en Opus 5.5, unas 2.7 veces más. Las respuestas de Argon usaron 3,346 tokens de entrada y 3,525 de salida en total; las de Opus 5.5, 4,419 y 4,692. Las dos API informaron 0 tokens de pensamiento en cada llamada, así que el razonamiento no añadió nada a la factura.

El precio de lista de Google es $2 por millón de tokens de entrada y $10 por millón de salida hasta el 30 de noviembre de 2026, y después $4 y $20 (precios de la API de Gemini, consultados el 4 de noviembre de 2026). El precio de lista de Anthropic para Opus 5.5 es $4 y $20 (precios de Anthropic, el mismo día). Desde el 1 de diciembre los mismos tokens cuestan el doble en Argon, lo que acerca a los dos. Las tarifas de ambos modelos están en la página de precios.

Ocho tareas no separan a dos modelos de frontera en calidad. Elige por velocidad, precio y la versión de Python con la que corres tus pruebas.

Lo que dicen quienes lo usan

La división también aparece en comentarios públicos. En Hacker News, el 31 de octubre, A_D_E_P_T escribió: «Gemini 4-Argon is very good at coding. I prefer Opus 5.5 -- in large part because I've grown accustomed to Claude Code -- but Argon is undeniably strong». El 28 de octubre, seizethecheese escribió sobre los agentes de código locales: «Argon is really bad. Literally the worst model in our initial ranking», con Opus 5.5 en cabeza. El 13 de octubre, ariwilson contó que Argon «solved 10 of 11» correcciones de errores pequeñas de sus propios proyectos.

Son opiniones de usuarios sobre sus propias configuraciones, no pruebas controladas. El comentario negativo viene de alguien que probaba un entorno de agentes, no una llamada directa a la API como las nuestras.

El único fallo: Python 3.9 no puede importar la respuesta de Argon

La respuesta de duraciones de Argon añadió una anotación de tipo float | int | Decimal a una función auxiliar. Python 3.9 no puede evaluarla al importar, así que el módulo lanzó TypeError: unsupported operand type(s) for |: 'type' and 'type' y las 14 pruebas fallaron antes de ejecutarse.

La lógica estaba bien. El mismo archivo se importó y pasó 14 de 14 en Python 3.14.3. La sintaxis de unión necesita Python 3.10 o posterior.

El marcador depende del intérprete: en el Python 3.9.6 del sistema, Argon terminó 91 de 105 comprobaciones y Opus 5.5 terminó 105. En 3.14 los dos terminaron 105.

Si una imagen de servidor o una máquina de CI todavía trae 3.9, ahí está la trampa. Dos hábitos la cubren: nombrar la versión de Python en el enunciado y puntuar en la versión más antigua que soportes. Para un objetivo 3.9, pide Union[float, int] o from __future__ import annotations al principio del archivo.

Qué dicen los benchmarks de Google

La ficha de modelo de Argon (consultada el 4 de noviembre de 2026) lista cinco pruebas de sus secciones de código y seguridad con una cifra de Opus 5.5. Argon gana tres y pierde dos.

Esas cifras son de octubre de 2026; la columna Notes está vacía en estas filas, así que no constan el nivel de thinking, el arnés ni el número de intentos. Las pruebas además son mucho más agénticas que nuestras funciones pequeñas.

El anuncio de Google del 13 de octubre dice que Argon lidera el Vals Index, que incluye código, y reporta una subida de más del 35% en envíos de código de agentes dentro de Antigravity. Las dos son cifras de Google.

Nuestra comparación de tres tareas con GPT-6 Astra del 23 de octubre tuvo a Argon pasando las 12 pruebas ocultas de una corrección de error de facturación. Argon pasó todas las comprobaciones allí y en la tarea 1 de aquí, y ningún resultado nuevo contradice eso.

Cómo ejecutar la misma prueba tú mismo

Un archivo de enunciado por tarea, enviado sin cambios a los dos modelos, es toda la preparación. El endpoint que usamos es https://api.omniakey.com/v1; los dos modelos están en las páginas de Gemini 4 Argon y Claude Opus 5.5.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.omniakey.com/v1",
    api_key=os.environ["OMNIAKEY_API_KEY"],
)
prompt = open("task6-duration.md").read()

for model in ("gemini-4-argon", "claude-opus-5-5"):
    reply = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
        max_tokens=8000,
    )
    open(f"{model}.md", "w").write(reply.choices[0].message.content)

1. Guarda cada tarea como su propio archivo de enunciado y envíalo sin cambios, sin prompt de sistema, para que los dos modelos reciban las mismas palabras.
2. Envía cada enunciado una vez por modelo en su nivel de thinking por defecto y anota el ID del modelo, el tiempo y los tokens.
3. Recorta el bloque de código de cada respuesta y guárdalo como el módulo que importan tus pruebas.
4. Ejecuta tus pruebas ocultas en un proceso aparte con tiempo límite e imprime los aciertos junto al total.
5. Repite la puntuación en el Python más antiguo que soportes. En la pasada de 3.9 apareció el único fallo de Argon.
6. Calcula el costo con los tokens devueltos y el precio de lista de cada proveedor.

Preguntas frecuentes

¿Gemini 4 Argon es bueno para programar?

En nuestras ocho tareas pasó las 105 pruebas ocultas en Python 3.14, igual que Opus 5.5. En la tabla de Google, Argon va por delante en tres de cinco filas y por detrás en dos.

¿Cuánto cuesta programar con Gemini 4 Argon?

Google cobra $2 por millón de tokens de entrada y $10 por millón de salida hasta el 30 de noviembre de 2026, y después $4 y $20. Nuestras ocho tareas salieron por $0.042 con el precio de introducción. Opus 5.5 salió por $0.112 con los $4 y $20 de Anthropic.

¿Gemini 4 Argon es más rápido que Claude Opus 5.5?

No. Opus 5.5 fue más rápido en las ocho tareas: 57.2 segundos en total frente a 139.6 de Argon. La brecha más ancha fue la tarea de duraciones, con 14.0 segundos frente a 60.9.

¿Por qué falló Argon una tarea?

No falló la lógica. Su respuesta de duraciones usaba una anotación float | int | Decimal, que Python 3.9 no puede evaluar al importar, así que las 14 pruebas fallaron antes de ejecutarse. El mismo archivo pasó 14 de 14 en Python 3.14.

Fuentes

• Página del modelo Gemini 4 Argon
• Precios de la API de Gemini
• Niveles de thinking de la API de Gemini
• Ficha del modelo Gemini 4 Argon
• Anuncio de Gemini 4 Argon
• Gemini 4 Argon en Vertex AI
• Precios de la API de Anthropic
• Resumen de Claude Opus 5.5
• Ajustes de effort de Anthropic

Todas consultadas el 4 de noviembre de 2026.

Registro de cambios

• 4 de noviembre de 2026: primera publicación. Pruebas ejecutadas el 4 de noviembre, puntuadas en Python 3.9.6 y otra vez en 3.14.3.