
La Gemini 4 Carbon API y la Gemini 4 Argon API aceptan la misma solicitud y cuestan lo mismo por token de entrada y de salida, así que elegir entre ellas es una decisión de enrutamiento, no una migración. En PoYo cambias de una a otra modificando una sola cadena: gemini-4-carbon (página del modelo) o gemini-4-argon (página del modelo). Este artículo explica qué cambia a nivel de API, qué dicen las diferencias de benchmarks de Google sobre qué solicitudes deben ir a Carbon y un enrutador que puedes integrar en tu código.
¿Es la primera vez que usas Carbon? Empieza por el resumen de la Gemini 4 Carbon API y la guía de la primera solicitud. Para Argon por separado, consulta la guía de la API de Gemini 4 Argon.
Gemini 4 Carbon API frente a Gemini 4 Argon API de un vistazo
| Gemini 4 Carbon | Gemini 4 Argon | |
|---|---|---|
| ID de modelo en PoYo | gemini-4-carbon | gemini-4-argon |
| Endpoints en PoYo | POST /v1/chat/completions, POST /v1beta/models/gemini-4-carbon:generateContent / :streamGenerateContent | Los mismos dos formatos, con gemini-4-argon |
| Ventana de contexto | 1M tokens | 1M tokens |
| Salida máxima por respuesta | 64K tokens | Mayor: Google describe un límite unificado de entrada y salida de 1M (consulta nuestra guía de Argon) |
| Tipos de entrada | Texto, imagen, audio, vídeo, PDF | Texto, imagen, audio, vídeo, PDF |
| Posicionamiento de Google | El modelo de razonamiento más potente; gasta más tokens para explorar, razonar y verificar | Modelo eficiente: respuestas más rápidas y menor gasto de tokens por turno |
| Recomendación de Google | La programación de varios pasos más difícil, depuración, investigación abierta | «La opción ideal para la mayoría del trabajo de ingeniería de software y de conocimiento» |
La estructura de la solicitud es idéntica. En Chat Completions, el ID de modelo va en el campo model; en Gemini Native, va en la ruta de la URL. Ambos modelos admiten streaming ("stream": true o :streamGenerateContent). Los errores también son los mismos: 400 para campos no válidos o un formato incorrecto, 401 para una clave errónea, 404 para un ID de modelo desconocido y 402 cuando se agotan tus créditos.
El único límite que obliga a elegir una ruta es el tamaño de la salida. El techo documentado de Carbon es de 64K tokens de salida por respuesta. Si una sola respuesta debe superar esa cifra (por ejemplo, reescribir varios archivos completos de una sola pasada), envíala a Argon.
Diff de migración: qué cambia en el JSON
Pasar una solicitud de Argon a Carbon en Chat Completions:
{
- "model": "gemini-4-argon",
+ "model": "gemini-4-carbon",
"messages": [
{"role": "user", "content": "Find the root cause of the failing test and propose a patch."}
],
- "max_tokens": 120000,
+ "max_tokens": 64000,
"stream": true
}
En Gemini Native solo cambia la ruta:
POST https://api.poyo.ai/v1beta/models/gemini-4-argon:generateContent
POST https://api.poyo.ai/v1beta/models/gemini-4-carbon:generateContent
Limita max_tokens (Chat Completions) o generationConfig.maxOutputTokens (Gemini Native) a 64.000 o menos cuando llames a Carbon. No hace falta cambiar nada más en el cuerpo.
Precio por token: igual, salvo las lecturas de caché
Precios de PoYo, según las páginas de modelo actuales (1 crédito = 0,005 $):
| Medidor (por 1M de tokens) | Gemini 4 Carbon en PoYo | Gemini 4 Argon en PoYo | Precio oficial de Google (ambos, introductorio) |
|---|---|---|---|
| Entrada | $1.60 (320 créditos) | $1.60 (320 créditos) | $2.00 |
| Salida (incl. razonamiento) | $8.00 (1,600 créditos) | $8.00 (1,600 créditos) | $10.00 |
| Lectura de caché | $0.08 (16 créditos) | $0.16 (32 créditos) | $0.10 (95% de descuento sobre la entrada) |
Google lanzó Carbon con el precio introductorio de Argon. Su artículo de disponibilidad indica que el periodo introductorio termina el 30 de noviembre de 2026 y que a partir del 1 de diciembre se aplican 4 $ de entrada y 20 $ de salida por cada millón de tokens. El artículo de precios de Carbon compara ambas tarifas de Google con el precio actual de PoYo.
La diferencia está en la línea de lectura de caché: en PoYo, las lecturas de caché de Carbon cuestan la mitad que las de Argon. Ese ahorro es real, pero pequeño. Son 0,08 $ por cada millón de tokens en caché, y 10.000 tokens de salida adicionales (0,08 $ a 8,00 $ por 1M) lo anulan. Como Google afirma que Carbon gasta más tokens por tarea que Argon, cuenta con que Carbon cueste más por tarea en la mayoría de las cargas de trabajo, incluso con la caché más barata.
Un ejemplo práctico con recuentos de tokens idénticos (400K lecturas de caché, 50K de entrada nueva, 20K de salida):
| Carbon | Argon | |
|---|---|---|
| Cálculo | 0.4 × $0.08 + 0.05 × $1.60 + 0.02 × $8.00 | 0.4 × $0.16 + 0.05 × $1.60 + 0.02 × $8.00 |
| Coste | $0.272 (54.4 créditos) | $0.304 (60.8 créditos) |
Si Carbon necesita 30K tokens de salida para la misma tarea en lugar de 20K, cuesta 0,352 $. Por eso conviene medir el coste por tarea completada, no el coste por token. El script de medición está más abajo.
Diferencias de benchmarks como criterio de enrutamiento
Estas son las cifras de la propia Google, de la tabla de lanzamiento de Gemini 4 Carbon, así que tómalas como la comparación del proveedor, no como una prueba independiente. La columna de diferencia indica dónde compensan los tokens adicionales.
| Benchmark | Carbon | Argon | Diferencia |
|---|---|---|---|
| ExploitGym | 54.8% | 42.0% | +12.8 |
| GraphWalks 256K–1M (BFS F1) | 96.2% | 84.2% | +12.0 |
| AA Intelligence Index v5.0 | 59 | 50 | +9 |
| Agents' Last Exam v1.1 | 77.4% | 69.0% | +8.4 |
| Terminal-Bench 4.0 (AA) | 65.2% | 57.1% | +8.1 |
| OSWorld-2.1 (subconjunto offline) | 81.5% | 74.7% | +6.8 |
| FrontierSWE 2 | 61.2% | 55.0% | +6.2 |
| SWE-sweep | 9.6% | 4.3% | +5.3 |
| SEC-bench Pro | 88.2% | 83.4% | +4.8 |
| RiemannBench | 80.0% | 76.0% | +4.0 |
| CWE-bench | 71.0% | 68.0% | +3.0 |
| AutomationBench (Zapier) | 53.9% | 51.3% | +2.6 |
| Vals Index v2.2 | 70.4% | 69.2% | +1.2 |
Léela como una tabla de enrutamiento:
- Diferencias grandes: envía a Carbon. Recuperación con contexto largo en 256K–1M tokens, trabajo de agentes en terminal, tareas de agentes de varios pasos y validación de exploits.
- Diferencias pequeñas: mantén en Argon. Automatización empresarial (+2,6), trabajo de conocimiento general (Vals Index, +1,2) y generación de parches en CWE-bench (+3,0). Aquí Argon obtiene casi toda la puntuación gastando menos tokens por turno.
- Advertencia sobre ciberseguridad. Los resultados de ciberseguridad de Google reflejan el acceso a través de su Fairwind Program, y su artículo de disponibilidad indica que Carbon para ciberseguridad solo se ofrece a través de ese programa. No des por hecho que la API pública reproduce esas puntuaciones. Haz pruebas con tus propias tareas.
Compara puntuaciones solo dentro de una misma tabla. Nuestra guía de Argon cita la tabla de lanzamiento de Argon de Google, que da a Argon un 57,4% en Terminal-Bench 4.0. La tabla de Carbon usa el harness de Artificial Analysis (57,1%).
Estrategia de enrutamiento: Argon por defecto, escalar a Carbon
Las recomendaciones de Google y las diferencias de benchmarks apuntan al mismo diseño:
- Envía por defecto cada solicitud a
gemini-4-argon. - Envía directamente a
gemini-4-carbonlos tipos de tarea que ya sabes que son difíciles: depuración a nivel de repositorio, agentes de terminal, preguntas sobre más de 256K tokens de contexto y triaje de seguridad. - Escala cuando falle. Si la respuesta de Argon no supera tu comprobación (tests, validación de esquema, un evaluador) o se detiene con
finish_reason: "length", reintenta una vez con Carbon. - Fuerza Argon cuando la respuesta deba superar los 64K tokens.
Este enrutador usa el SDK de OpenAI apuntando al endpoint Chat Completions de PoYo. Solo envía campos documentados: model, messages y max_tokens.
import os
from openai import OpenAI
client = OpenAI(api_key=os.environ["POYO_API_KEY"], base_url="https://api.poyo.ai/v1")
ARGON, CARBON = "gemini-4-argon", "gemini-4-carbon"
CARBON_MAX_OUTPUT = 64_000
# PoYo USD per 1M tokens, from the model pages on 2026-11-16
PRICE = {ARGON: (1.60, 8.00), CARBON: (1.60, 8.00)}
# Task types where Google's table shows the widest Carbon lead
CARBON_TASKS = {"repo_debug", "terminal_agent", "long_context_qa", "security_triage"}
def pick_model(task_type: str, max_tokens: int) -> str:
if max_tokens > CARBON_MAX_OUTPUT:
return ARGON
return CARBON if task_type in CARBON_TASKS else ARGON
def call(model: str, messages: list, max_tokens: int) -> dict:
resp = client.chat.completions.create(model=model, messages=messages, max_tokens=max_tokens)
u = resp.usage
price_in, price_out = PRICE[model]
cost = u.prompt_tokens / 1e6 * price_in + u.completion_tokens / 1e6 * price_out
return {
"model": resp.model,
"text": resp.choices[0].message.content,
"finish_reason": resp.choices[0].finish_reason,
"prompt_tokens": u.prompt_tokens,
"completion_tokens": u.completion_tokens,
"cost_usd": round(cost, 6),
}
def run(task_type: str, messages: list, check, max_tokens: int = 16_000) -> list:
"""Returns every attempt so you can log cost per task, including escalations."""
first = pick_model(task_type, max_tokens)
attempts = [call(first, messages, max_tokens)]
a = attempts[-1]
failed = a["finish_reason"] == "length" or not check(a["text"])
if first == ARGON and failed and max_tokens <= CARBON_MAX_OUTPUT:
attempts.append(call(CARBON, messages, max_tokens))
return attempts
check es tu propia prueba de aceptación, por ejemplo «el parche se aplica y los tests pasan» o «el JSON se valida contra mi esquema». La estimación de coste trata cada token del prompt como entrada sin caché. Los campos de uso documentados por PoYo no desglosan los tokens en caché, así que es un límite superior.
Mide tú mismo el coste por tarea
Los precios por token son iguales, así que la única cifra que distingue ambas API es el coste por tarea aceptada. Registra cada intento de run():
| Campo que registrar | Origen en Chat Completions | Origen en Gemini Native |
|---|---|---|
| Modelo realmente usado | model | Ruta de la URL |
| Tokens de entrada | usage.prompt_tokens | usageMetadata.promptTokenCount |
| Tokens de salida | usage.completion_tokens | usageMetadata.candidatesTokenCount + thoughtsTokenCount |
| Alcanzó el límite de salida | finish_reason == "length" | finishReason |
| Superó tu comprobación | tu evaluador | tu evaluador |
Google cobra la salida incluyendo los tokens de razonamiento, así que en Gemini Native cuenta thoughtsTokenCount como salida. Con streaming, el último fragmento de Chat Completions incluye usage. Después, por tipo de tarea:
cost per accepted task = sum(cost_usd of all attempts, incl. escalations) / tasks that passed
Pasa una semana de tráfico real con Argon por defecto y compáralo con una muestra enviada directamente a Carbon. Si Carbon supera tareas para las que Argon necesitó escalar, añade ese tipo de tarea a CARBON_TASKS. Si la tasa de aciertos de Carbon en un tipo es igual a la de Argon, mantén ese tipo en Argon. Compara tu panel de PoYo con tu registro durante las primeras cientos de llamadas.
Si también estás valorando modelos de otros proveedores, consulta Gemini 4 Carbon API vs Claude Opus 5.5 API vs GPT-6 Astra API. Para un bucle de agente con controles de presupuesto, consulta Gemini 4 Carbon API para agentes de programación.
Preguntas frecuentes
¿La Gemini 4 Carbon API es más cara que la Gemini 4 Argon API?
No por token. Ambas cuestan 1,60 $ de entrada y 8,00 $ de salida por cada millón de tokens en PoYo, y 2,00 $ / 10,00 $ con el precio introductorio de Google. En PoYo, la lectura de caché de Carbon es más barata (0,08 $ frente a 0,16 $ por 1M). Por tarea, Carbon suele costar más porque, según Google, usa más tokens para razonar y verificar.
¿Cómo paso de la Gemini 4 Argon API a la Gemini 4 Carbon API?
Cambia "model": "gemini-4-argon" por "model": "gemini-4-carbon" en Chat Completions, o cambia el modelo en la ruta de la URL de Gemini Native. Mantén max_tokens en 64.000 o menos para Carbon.
¿Cuál es la salida máxima de la Gemini 4 Carbon API en comparación con Argon?
Carbon devuelve hasta 64K tokens de salida por respuesta, con una ventana de contexto de 1M de tokens. Argon permite respuestas individuales mucho más largas, así que envía a Argon las salidas de más de 64K.
¿Debo usar Gemini 4 Argon o Gemini 4 Carbon para programar?
Google afirma que Argon sigue siendo la opción ideal para la mayoría del trabajo de ingeniería de software. Usa Carbon para la depuración de varios pasos más difícil y para el trabajo de agentes en terminal, donde la tabla de Google muestra las mayores diferencias: Terminal-Bench 4.0 (AA) 65,2% frente a 57,1%, y SWE-sweep 9,6% frente a 4,3%.
¿Gemini 4 Carbon y Argon usan el mismo endpoint de API?
Sí. Ambos funcionan con POST https://api.poyo.ai/v1/chat/completions (compatible con OpenAI) y POST https://api.poyo.ai/v1beta/models/{model}:generateContent o :streamGenerateContent (Gemini Native), con la misma clave de API de PoYo.