Construye con CometAPI¿Necesitas una sola API para varios modelos?Prueba el flujo en el Playground y luego crea una clave de API cuando el modelo y el costo encajen con tu caso de uso.
¿Cómo usar la API de Gemini 4 Carbon? Una guía completa para desarrolladores
Configura la API Gemini 4 Carbon con CometAPI. Sigue los ejemplos de Python y REST, valida las respuestas, analiza archivos PDF e imágenes y gestiona el streaming.
Deon GoodwinEquipo de investigación de modelos de IA y API
Usa la Gemini 4 Carbon API en CometAPI para añadir razonamiento y análisis de documentos a tu aplicación mediante la interfaz nativa GenerateContent de Gemini. Empieza con una solicitud de texto corta, verifica que la generación haya finalizado y guarda la respuesta antes de añadir entrada en PDF, imágenes, streaming o JSON estructurado. Esta guía proporciona la configuración y el código de manejo de respuestas para cada paso.
Key Takeaways
ID del modelo: gemini-4-carbon. Sin nivel gratuito: requiere Gemini API de pago / Cloud Billing.
Ventana unificada de 1M de tokens (entrada + razonamiento + salida). Salida máxima predeterminada ~65K; la decodificación larga se extiende hasta casi 1M.
Niveles de razonamiento: (rápido/barato), (predeterminado, equilibrado), (razonamiento profundo).
Revisado para mayor claridad, atribución de fuentes y terminología API actual.
low
medium
high
Precio introductorio hasta el 30 de noviembre de 2026: $2 / $10 por 1M de tokens (entrada en caché $0.10). Se duplica el 1 de diciembre.
Excelente para codificación agente de largo horizonte, razonamiento científico, trabajo de conocimiento y tareas de ciberseguridad.
SDKs oficiales (google-genai) + endpoints compatibles con OpenAI disponibles.
CometAPI ofrece el acceso a producción más sencillo con una sola clave, tarifas competitivas y cambio fluido entre Gemini 4 Carbon, Claude y más de 500 modelos.
Obra de lanzamiento de Gemini 4 Carbon. Imagen: Google. Obra original.
What Is Gemini 4 Carbon API?
Gemini 4 Carbon es el modelo de razonamiento de frontera de Google para flujos de trabajo agentes de largo horizonte, ingeniería de software compleja, ciberseguridad e investigación científica. Construido sobre Gemini 4 Argon, utiliza razonamiento más profundo y bucles de verificación extendidos para abordar tareas de múltiples pasos que requieren resolución sostenida de problemas en lugar de una única respuesta. En comparación con Argon, Carbon está diseñado para cargas de trabajo más exigentes donde la precisión y la finalización de tareas importan más que minimizar el uso de tokens. Google anunció el acceso de pago para desarrolladores el 10 de noviembre de 2026. Su soporte de entrada multimodal te permite combinar texto con entradas visuales y otros medios; la salida generada es texto. CometAPI ofrece acceso con descuento a la API.
Para una integración de API, comienza con una tarea cuyo resultado puedas comprobar: resumir un documento, extraer campos de una nota de incidente o revisar una captura de pantalla. Un flujo de trabajo agente más amplio puede construirse sobre esa solicitud funcional una vez que hayas verificado las herramientas y el comportamiento de respuesta del trayecto elegido.
Other Ways to Use It
Google AI Studio Playground: selecciona el modelo y prueba prompts de forma interactiva (requiere acceso de pago para Carbon).
Gemini app / AI Mode / Antigravity: disponible si tienes Google AI Ultra (selecciona el modelo donde esté disponible).
Enterprise / Cloud: úsalo mediante Gemini Enterprise Agent Platform o endpoints tipo Vertex con el mismo ID de modelo (configuración de proyecto + ubicación).
Científicos/investigadores pueden solicitar acceso gratuito limitado en algunos casos.
What Are the Gemini 4 Carbon API Specifications ?
Las especificaciones oficiales del modelo distinguen el presupuesto de contexto compartido del límite de salida de cada segmento en primer plano. Estos son límites a nivel de modelo; tu gateway también puede aplicar restricciones de tamaño de solicitud y funciones.
Limitations and API Considerations
Antes de ampliar tu integración, revisa cómo Carbon maneja el contexto, los ajustes de generación, el caché y el acceso. La tabla empareja cada restricción con una acción práctica para evitar solicitudes no válidas, resultados incompletos y costos inesperados.
Area
Limitation or requirement
Developer implication
Unified token budget
Input and output share 1,048,576 tokens, including thinking and function calls.
Reserve output space before adding conversation history or files.
Long decoding
A foreground segment allows up to 65,536 output tokens when streaming, or 32,768 without streaming;
longer generation needs continuation.
Thinking levels
Low, Medium, High; Medium is default
For GenerateContent, send LOW, MEDIUM, or HIGH; MINIMAL is rejected.
Thinking budget
Legacy thinking_budget parameter is rejected
Remove thinking_budget from request builders and use thinking_config.thinking_level in Python, or thinkingConfig.thinkingLevel in REST JSON.
Sampling
Custom temperature, top_p, and top_k values are ignored
Use thinking_level to select reasoning depth and response_schema for structured output.
Context caching
Implicit caching is supported; explicit context-cache creation is not.
Put reusable context first and the changing question last. Remove explicit cache-creation calls and cached_content references
API cost
Thinking tokens are billed as output
Count thinking as well as visible output.
Cybersecurity access
Specialized cyber access is restricted
Check eligibility for specialized Fairwind access. Standard Carbon access does not by itself grant access to the cyber-permissive variant.
Reliability
Hallucinations, occasional timeouts, and higher token usage can occur
Validate facts, code, and extracted fields.
La guía para desarrolladores de Carbon de Google documenta las reglas de la API; su model card describe la fiabilidad y las limitaciones de acceso especializado. Confirma las funciones correspondientes en tu ruta de CometAPI antes de habilitarlas en producción.
Thinking Levels: How to Choose the Right Setting
Empieza con MEDIUM y ajusta el nivel a la tarea y a la calidad que necesitas.
LOW: Úsalo para extracción, clasificación y resúmenes simples cuando el tiempo de respuesta y el costo tengan prioridad. Pruébalo en tareas como etiquetar tickets de soporte y verifica que siga cumpliendo tu objetivo de precisión.
MEDIUM: Úsalo como punto de partida predeterminado para codificación diaria, análisis de documentos y razonamiento rutinario. Es una base práctica para evaluar si un nivel distinto mejora tu aplicación.
HIGH: Úsalo para depuración compleja, investigación de múltiples pasos y razonamiento científico que se beneficien de una indagación más profunda. Permite tokens adicionales de razonamiento y mantenlo solo cuando la mejora de calidad justifique el costo y tiempo añadidos.
Los niveles más altos de razonamiento no garantizan automáticamente mejores resultados para cada tarea. Realiza benchmarks con tus propias cargas de trabajo y compara calidad de finalización, latencia y uso total de tokens antes de cambiar los valores predeterminados en producción.
How Does Gemini 4 Carbon Perform on AI Benchmarks?
Selected Benchmark Results
Benchmark
Gemini 4 Carbon
Gemini 4 Argon
GPT-6 Astra
Claude Opus 5.5
Artificial Analysis Intelligence Index v5.0
59
50
57
58
SWE-sweep
9.60%
4.30%
9.50%
3.60%
FrontierSWE 2
61.20%
55.00%
65.50%
62.30%
Terminal-Bench 4.0
65.20%
57.10%
59.10%
59.60%
Agents' Last Exam v1.1
77.40%
69.00%
73.10%
71.60%
OSWorld-2.1
81.50%
74.70%
80.90%
87.20%
AutomationBench
53.90%
51.30%
41.40%
42.50%
Chartography
72.50%
71.60%
71.00%
66.30%
GraphWalks (256K–1M)
96.20%
84.20%
71.80%
66.80%
Las páginas Artificial Analysis Carbon (High) y Argon (High) muestran la siguiente instantánea, consultada el 12 de noviembre de 2026. Estos son resultados de benchmarks, no mediciones de latencia de CometAPI.
Metric
Carbon (High)
Argon (High)
Intelligence Index
60
50
Output speed
80 tokens/s
65 tokens/s
Time to first answer token
67.83 s
37.64 s
Time per Intelligence Index task
25.5 min
30.0 min
Output tokens across the evaluation
205M
113M
Cost per Intelligence Index task
$7.76
$9.95
Los totales de tokens de salida cubren toda la evaluación, no una sola solicitud. El costo por tarea usa los supuestos de precios de Artificial Analysis en lugar del descuento actual de CometAPI. Carbon espera más antes de su primer token de respuesta, pero completa la tarea del benchmark más rápido y con menor costo reportado; el volumen de tokens por sí solo no determina el valor.
Usa Carbon cuando su verificación más profunda mejore revisiones de código difíciles, investigaciones u otros trabajos costosos de equivocarse. Prueba Argon para codificación rutinaria y tareas de conocimiento, pero confirma los ahorros en tu propia carga de trabajo. Ejecuta prompts idénticos y compara el gasto total dividido por resultados aceptados, junto con el tiempo de finalización y la tasa de fallos.
How Do You start with the Gemini 4 Carbon API in CometAPI?
Necesitarás una cuenta de CometAPI con acceso al modelo y crédito suficiente, un entorno Python y familiaridad básica con la ejecución de scripts. Utiliza un directorio de proyecto para los archivos de abajo, de modo que cada ejemplo pueda importar la misma configuración de cliente.
Why Use Gemini 4 Carbon API Through CometAPI?
CometAPI es útil cuando quieres evaluar Carbon junto con otros modelos gestionando acceso y facturación mediante un solo proveedor. Su ruta de Carbon ofrece tanto la interfaz nativa GenerateContent de Gemini como una interfaz Chat compatible con OpenAI, para que puedas elegir el formato de solicitud que encaje en tu aplicación.
Para esta guía, la ruta nativa te permite reutilizar el SDK de Google Gen AI con una clave y base URL de CometAPI. Los precios actuales del grupo predeterminado están un 20% por debajo de las tarifas introductorias de Google. Mantén el ID del modelo en la configuración para comparar Carbon y Argon sin reescribir tu aplicación, y verifica el soporte específico de la ruta antes de añadir herramientas, subidas de archivos o continuaciones largas.
Step 1: Create Your Account and Set Your API Key
Inicia sesión en CometAPI, crea o abre tu clave de API y guárdala como variable de entorno. Evita poner claves directamente en el código fuente o confirmarlas en un repositorio.
Usa el comando para tu shell. Establece las variables en la misma terminal donde ejecutarás Python; sustituye el marcador de clave por tu propia clave.
Step 2: Install the SDK and Configure the Endpoint
Instala el SDK en tu entorno de proyecto. Usar python -m pip hace que el instalador quede ligado al intérprete que ejecutará el ejemplo.
Instala o actualiza el SDK de Google Gen AI.
python -m pip install --upgrade google-genai
CometAPI documenta un endpoint nativo de Gemini con una base URL personalizada para el SDK. Usa tu clave de CometAPI para este endpoint. Los ajustes siguientes aplican a solicitudes GenerateContent.
Setting
Value
SDK
google-genai
Base URL
https://api.cometapi.com
API version
v1beta
REST authentication header
x-goog-api-key
Key environment variable
COMETAPI_KEY
Model environment variable
COMETAPI_MODEL
Model ID
gemini-4-carbon
Step 3: Create a Reusable Client and Validate Responses
Guarda esta configuración como carbon_client.py. Define el cliente una vez y proporciona completed_text para las respuestas solo de texto usadas en esta guía. El helper comprueba la razón de finalización del candidato antes de devolver el texto de la respuesta, de modo que un resultado vacío o truncado no se trate silenciosamente como éxito.
Crea carbon_client.py con el cliente de CometAPI y un validador de respuestas de texto.
import os
from google import genai
from google.genai import types
client = genai.Client(
api_key=os.environ["COMETAPI_KEY"],
http_options={
"api_version": "v1beta",
"base_url": "https://api.cometapi.com",
},
)
model = os.getenv("COMETAPI_MODEL", "gemini-4-carbon")
def completed_text(response):
if not response.candidates:
raise RuntimeError("No candidate returned; inspect prompt feedback.")
candidate = response.candidates[0]
reason = getattr(candidate.finish_reason, "value", candidate.finish_reason)
if reason != "STOP":
raise RuntimeError(f"Generation did not finish normally: {reason}")
parts = candidate.content.parts if candidate.content else []
text = "".join(
part.text or "" for part in (parts or []) if not part.thought
)
if not text.strip():
raise RuntimeError("The completed candidate contains no answer text.")
return text
Step 4: Send Your First Request and Check the Result
Crea first_request.py junto a carbon_client.py y añade el siguiente código. Envía un prompt breve de checklist usando razonamiento MEDIUM y un presupuesto de salida de 4,096 tokens, verifica la finalización con completed_text(response) y guarda la respuesta en answer.txt como UTF-8. Ejecuta python first_request.py desde tu directorio de proyecto, luego abre answer.txt y confirma que los cinco puntos de revisión son relevantes y utilizables. Revisa la metadata de uso impresa para el consumo de tokens, incluyendo el razonamiento; una finalización normal no establece la calidad de la respuesta. Si la solicitud falla o devuelve salida incompleta, usa la sección de troubleshooting para comprobar credenciales, detalles del error y la razón de finalización antes de reintentar.
from pathlib import Path
from carbon_client import client, model, types, completed_text
response = client.models.generate_content(
model=model,
contents="Give me a five-point checklist for reviewing a Python API client.",
config=types.GenerateContentConfig(
max_output_tokens=4096,
thinking_config=types.ThinkingConfig(thinking_level="MEDIUM"),
),
)
answer = completed_text(response)
Path("answer.txt").write_text(answer, encoding="utf-8")
print(answer)
print("Saved answer.txt")
if response.usage_metadata:
print(response.usage_metadata.model_dump(exclude_none=True))
python first_request.py
## How Can Gemini 4 Carbon API Analyze Files?
Ejecuta estos ejemplos desde el mismo directorio que carbon_client.py. Cargan archivos locales en partes de contenido inline, manteniendo el flujo inicial independiente de un servicio separado de subida de archivos.
La comprensión de PDF incluye contenido visual: Gemini puede interpretar texto, tablas, gráficos e imágenes en conjunto. La [guía de procesamiento de documentos de Google](https://ai.google.dev/gemini-api/docs/document-processing) describe soporte para PDFs de hasta 1,000 páginas, sujeto a límites de tamaño de archivo y contexto. El número de páginas es un techo, no una garantía de que cada documento encaje en una solicitud del gateway.
Usa entrada inline para PDFs pequeños y temporales. Para archivos más grandes o preguntas repetidas multi-turn, Google recomienda la Files API para evitar reenviar el archivo completo. Antes de usar ese flujo a través de CometAPI, verifica su endpoint de subida y el soporte de referencias a archivos; el ejemplo inline siguiente sigue siendo un punto de partida práctico.
### Summarize a local PDF
Google documenta la [entrada inline de PDF](https://ai.google.dev/gemini-api/docs/document-processing) para GenerateContent. Coloca un report.pdf pequeño y no sensible en el directorio del proyecto, luego guarda lo siguiente como analyze_pdf.py y ejecuta python analyze_pdf.py.
Envía un PDF local y guarda su resumen completado.
from pathlib import Path
from carbon_client import client, model, types, completed_text
response = client.models.generate_content(
model=model,
contents=[
types.Part.from_bytes(
data=Path("report.pdf").read_bytes(),
mime_type="application/pdf",
),
"Summarize this report in five bullets. Do not invent missing figures.",
],
config=types.GenerateContentConfig(max_output_tokens=4096),
)
Compara el resumen con el archivo antes de expandirte a documentos más grandes. Los límites de tamaño de solicitud y el soporte de referencias a archivos dependen del gateway. El soporte de Google para formatos de Office o referencias a Cloud Storage no establece por sí solo soporte para esas entradas en tu ruta de CometAPI.
### Review a local screenshot
Para [entrada de imagen inline](https://ai.google.dev/gemini-api/docs/image-understanding), haz coincidir el tipo MIME con el archivo. Coloca una captura PNG llamada screen.png junto al script. Guarda este ejemplo como analyze_image.py y ejecuta python analyze_image.py para revisar el texto visible y el layout.
Analiza una captura PNG sin depender de una URL pública de imagen.
from pathlib import Path
from carbon_client import client, model, types, completed_text
response = client.models.generate_content(
model=model,
contents=[
types.Part.from_bytes(
data=Path("screen.png").read_bytes(),
mime_type="image/png",
),
"Review this screenshot for unreadable text and overlapping elements. "
"Describe only visible issues and identify their locations.",
],
config=types.GenerateContentConfig(max_output_tokens=4096),
)
print(completed_text(response))
Compara cada problema reportado con la captura de pantalla. Si envías un JPEG en su lugar, cambia tanto el nombre del archivo como el tipo MIME para que coincidan; cambiar solo la extensión no convierte la imagen.
## How Do You Stream Gemini 4 Carbon Responses ?
### Display streamed text and check completion
El streaming devuelve fragmentos de respuesta como eventos enviados por el servidor (SSE), lo que permite a una aplicación mostrar la salida parcial mientras continúa la generación.
El SDK expone la [generación de texto en streaming](https://ai.google.dev/gemini-api/docs/text-generation) mediante generate_content_stream. Para solicitudes HTTP directas, CometAPI usa streamGenerateContent con alt=sse.
Guarda lo siguiente como stream_response.py y ejecuta python stream_response.py. Muestra el texto conforme llega, luego verifica que el stream haya terminado con una razón de finalización normal. Una excepción deja el texto mostrado como resultado parcial, no como respuesta aceptada.
Lee texto en streaming y exige una finalización normal antes de aceptarlo.
from carbon_client import client, model, types
finish_reason = None
received_text = False
for chunk in client.models.generate_content_stream(
model=model,
contents="Write a concise checklist for investigating intermittent API timeouts.",
config=types.GenerateContentConfig(max_output_tokens=4096),
):
if not chunk.candidates:
continue
candidate = chunk.candidates[0]
if candidate.finish_reason is not None:
finish_reason = getattr(candidate.finish_reason, "value", candidate.finish_reason)
parts = candidate.content.parts if candidate.content else []
for part in parts or []:
if part.text and not part.thought:
received_text = True
print(part.text, end="", flush=True)
print()
if finish_reason != "STOP" or not received_text:
raise RuntimeError(f"Stream not accepted as complete: {finish_reason}")
### Extract structured JSON
Para [salida restringida por esquema](https://ai.google.dev/gemini-api/docs/structured-output), solicita application/json y define los campos que tu aplicación espera. Este ejemplo extrae dos campos de una nota de incidente breve, luego comprueba sus tipos antes de imprimir el resultado.
Guarda este ejemplo como structured_output.py y ejecuta python structured_output.py. Reutiliza el validador de respuesta antes de parsear el JSON.
Extrae campos de incidente, comprueba la finalización y valida sus tipos.
import json
from carbon_client import client, model, types, completed_text
response = client.models.generate_content(
model=model,
contents=(
"Extract the service and impact from this incident note: "
"The checkout API returned errors for ten minutes during a database restart."
),
config=types.GenerateContentConfig(
max_output_tokens=4096,
response_mime_type="application/json",
response_schema={
"type": "OBJECT",
"properties": {
"service": {"type": "STRING"},
"impact": {"type": "STRING"},
},
"required": ["service", "impact"],
},
),
)
data = json.loads(completed_text(response))
if not isinstance(data, dict) or not all(
isinstance(data.get(field), str) for field in ("service", "impact")
):
raise ValueError("The response does not match the expected field types.")
print(json.dumps(data, indent=2))
Deberías recibir un objeto que contenga service e impact. El cumplimiento del esquema no establece precisión factual: compara los valores extraídos con la entrada y aplica cualquier regla de negocio antes de almacenarlos o actuar sobre ellos.
## Gemini 4 Carbon API Price
La [tarifa introductoria de Google](https://blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-4-carbon-now-available/) se extiende hasta el 30 de noviembre de 2026; sus tarifas estándar entran en vigor el 1 de diciembre. Revisa las tarifas actuales de tu cuenta antes de presupuestar solicitudes posteriores.
Ambos modelos pertenecen a la familia Gemini 4, pero apuntan a cargas de trabajo diferentes.
| API pricing tier | Input / 1M tokens | Output / 1M tokens |
| ------------------------- | ----------------- | ------------------ |
| Standard (through Nov 30) | $2.00 | $10.00 |
| Standard (from Dec 1) | $4.00 | $20.00 |
| Batch (through Nov 30) | $1.00 | $5.00 |
| Batch (from Dec 1) | $2.00 | $10.00 |
| Flex (through Nov 30) | $1.00 | $5.00 |
| Priority (through Nov 30) | $3.60 | $18.00 |
Detalles adicionales de precios:
* Entrada en caché: $0.10 por millón de tokens hasta el 30 de noviembre, aumentando a $0.20 a partir del 1 de diciembre.
* Batch y Flex ofrecen procesamiento de menor costo para cargas de trabajo que pueden tolerar sus características de servicio.
* Los tokens de razonamiento se facturan como tokens de salida.
* Los tokens consumidos por instrucciones internas de herramientas y declaraciones de funciones también pueden ser facturables.
Google recomienda explícitamente Argon para la mayoría de tareas de ingeniería de software y conocimiento, reservando Carbon para tareas que requieren razonamiento más profundo y verificación extendida.
Recomendación práctica: Elige Carbon cuando el costo de un resultado incorrecto sea alto o cuando una tarea requiera exploración y verificación sustanciales. Elige Argon cuando necesites un razonamiento sólido con un presupuesto de tokens más eficiente.
### CometAPI Price
Según lo verificado el 12 de noviembre de 2026, el [programa del grupo predeterminado de CometAPI](https://www.cometapi.com/models/google/gemini-4-carbon/) lista $1.60 por millón de tokens de entrada, $8.00 por millón de tokens de salida incluyendo razonamiento, y $0.08 por millón de tokens de entrada en caché en aciertos de caché. Estas tarifas están un 20% por debajo de las tarifas introductorias correspondientes de Google.
La tarificación de CometAPI puede cambiar a medida que cambien las tarifas oficiales de Google. Compara la tarifa oficial actual con el descuento asociado a tu cuenta en lugar de tratar el precio en dólares de hoy como permanente. Si se mantiene el mismo 20% de descuento tras un cambio de tarifa, tu tarifa será la nueva tarifa oficial × 0.80; confirma la tarifa real de CometAPI antes de presupuestar. Otros grupos de cuenta pueden tener diferentes descuentos.
Para una solicitud con 100,000 tokens de entrada no en caché y 10,000 tokens de salida, incluido el razonamiento, el costo solo por tokens es de $0.24 a la tarifa mostrada de CometAPI: $0.16 por entrada más $0.08 por salida. Las mismas cantidades cuestan $0.30 a las tarifas introductorias de Google o $0.60 a sus tarifas de diciembre. Los 110,000 tokens combinados encajan dentro del presupuesto compartido del modelo.
Esta estimación excluye herramientas, reintentos y cualquier ajuste de precios específico de la cuenta. El costo de salida incluye tokens de razonamiento, por lo que un nivel de razonamiento más alto puede incrementar la factura incluso si la respuesta visible es breve.
### How to Optimize Gemini 4 Carbon API Costs?
Optimiza para el costo de un resultado correcto y utilizable. Una solicitud más barata es de poco valor si debes repetirla o reparar manualmente la respuesta.
1. Elige el razonamiento deliberadamente. Empieza en MEDIUM, prueba LOW para trabajos simples y usa HIGH cuando mejore la aceptación lo suficiente como para justificar el tiempo y los tokens añadidos.
2. Reutiliza contexto estable mediante caché implícito. Los flujos de trabajo de [Argon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-argon) y [Carbon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-carbon) no soportan creación explícita de caché de contexto; sí soportan caché implícito. Coloca primero las instrucciones y documentos reutilizables, seguidos de la pregunta cambiante. Google documenta elegibilidad para prefijos compartidos de al menos 4,096 tokens. Verifica aciertos reales de caché y cargos en tu ruta de CometAPI; la repetición no garantiza descuento.
3. Reduce trabajo innecesario. Envía páginas o extractos relevantes, solicita los campos de salida que necesitas y define un presupuesto de salida suficiente. El razonamiento cuenta para el uso de salida, por lo que un límite demasiado pequeño puede causar truncamiento y reintentos.
4. Mide todo el flujo de trabajo. Incluye razonamiento, uso de herramientas, reintentos y respuestas rechazadas en el gasto total. Guarda respuestas válidas para que fallos de almacenamiento posteriores no disparen otra generación.
5. Encamina por valor demostrado. Compara Carbon y Argon en tareas idénticas. Considera Batch o Flex solo cuando tu proveedor los soporte y la carga de trabajo pueda tolerar sus características de procesamiento.
Sigue el costo por resultado aceptado = gasto total del flujo de trabajo ÷ resultados aceptados. Revisa esto junto con la latencia y la calidad después de cambiar un modelo, prompt o nivel de razonamiento.
## Which API Format Should You Use for Gemini 4 Carbon?
Los desarrolladores pueden acceder a la [Gemini 4 Carbon API en CometAPI](https://www.cometapi.com/models/google/gemini-4-carbon/) mediante la API nativa de Gemini y una API Chat compatible con OpenAI. Usa la interfaz que coincida con el formato de solicitud de tu aplicación y los requisitos de funciones documentados.
| Interface | When it fits | Integration check |
| ----------------------------- | ---------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- |
| Gemini-native GenerateContent | The Python and REST examples in this guide; applications already using contents and generationConfig | Use the Gemini base URL and field names shown above |
| OpenAI-compatible Chat API | An existing application organized around chat messages | Check the Carbon route’s documented endpoint, fields, and supported features before adapting code |
La compatibilidad aplica a un endpoint y forma de solicitud concretos. No envíes campos de OpenAI Responses al endpoint nativo de Gemini, ni supongas que una ruta compatible con Chat también implementa Responses. Una aplicación con herramientas necesita un round-trip verificado desde una llamada de función hasta su resultado correspondiente, no solo un prompt de texto exitoso.
## How to Migrate from Gemini 4 Argon to Gemini 4 Carbon API?
Si tu aplicación con Argon ya usa la ruta nativa GenerateContent de CometAPI, comienza cambiando el modelo configurado a gemini-4-carbon. Mantén sin cambios la clave, la base URL, el prompt y la lógica de validación para la primera comparación. Tanto [Argon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-argon) como [Carbon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-carbon) comparten muchas convenciones de solicitud de Gemini 4; la limpieza de parámetros heredados solo es necesaria si esos campos siguen en tu aplicación.
### 1. Change the model and run a controlled comparison
En la configuración usada en esta guía, cambia COMETAPI\_MODEL de gemini-4-argon a gemini-4-carbon, luego reinicia el proceso de Python para que recargue la variable. Usa el mismo prompt representativo y nivel de razonamiento para ambos modelos. El siguiente ejemplo independiente reutiliza carbon_client.py y selecciona explícitamente Carbon:
from carbon_client import client, types, completed_text
response = client.models.generate_content(
model="gemini-4-carbon",
contents="Review this function for correctness: def add(a, b): return a + b",
config=types.GenerateContentConfig(
max_output_tokens=4096,
thinking_config=types.ThinkingConfig(thinking_level="MEDIUM"),
),
)
print(completed_text(response))
### 2. Check request settings and conversation history
Mantén LOW, MEDIUM o HIGH en GenerateContent. Elimina cualquier thinking\_budget remanente, MINIMAL o uso explícito de cached\_content. No confíes en temperature, top\_p o top\_k para controlar el resultado. Elimina frequency\_penalty, presence\_penalty y valores de candidate\_count superiores a 1. Si llamas a herramientas, preserva IDs de llamadas de función, nombres y orden de respuesta coincidentes. Estos son chequeos de compatibilidad, no funciones recién eliminadas de Argon.
### 3. Validate quality, cost, and latency before rollout
Ejecuta el mismo conjunto de pruebas en ambos modelos. Revisa éxito de la tarea, validación de JSON, ejecución de herramientas, finalización completa, tokens facturados y tiempo transcurrido. Mantén disponible la configuración de Argon, dirige una pequeña porción del tráfico a Carbon y amplía solo si cumple tus objetivos de aceptación y presupuesto.
### 4. Keep long-output support separate from the model switch
Comienza con solicitudes que finalicen en un solo segmento en primer plano. Si necesitas continuación, primero confirma que CometAPI soporta el endpoint y los campos de respuesta requeridos. Un cambio de nombre de modelo por sí solo no habilita el flujo de continuación v1beta1 de Google en la puerta de enlace v1beta de esta guía. Mantén la salida parcial como incompleta hasta que la generación finalice normalmente.
## Conclusion
Usa la primera solicitud exitosa como punto de partida para una prueba de integración. Añade solo los tipos de entrada y formatos de respuesta que tu aplicación necesita, luego verifica salidas completas, manejo de errores y costo en tareas representativas. Dirige una pequeña parte del tráfico a la nueva integración antes de ampliarla y mantén una configuración funcional conocida por si cambian los resultados.
## Gemini 4 Carbon FAQ
### How large is Gemini 4 Carbon's context window?
Gemini 4 Carbon soporta un límite unificado de contexto de entrada y salida de 1,048,576 tokens. Este presupuesto incluye entrada, razonamiento, llamadas a funciones y salida generada.
### What are Gemini 4 Carbon's strongest benchmarks?
Sus resultados destacados reportados incluyen 88.2% en SEC-bench Pro, 54.8% en ExploitGym, 71.0% en CWE-bench y 96.2% en GraphWalks. Estos resultados resaltan sus capacidades en ciberseguridad, contexto largo y razonamiento agente.
### How does Gemini 4 Carbon compare with Gemini 4 Argon?
Carbon mejora sustancialmente sobre Argon en varios benchmarks reportados, incluyendo Artificial Analysis Intelligence Index (59 vs. 50), SWE-sweep (9.6% vs. 4.3%) y SEC-bench Pro (88.2% vs. 83.4%). Su distinción principal es un rendimiento más sólido en razonamiento extendido y tareas agentes complejas.
### Is Gemini 4 Carbon better than Claude Opus 5.5?
Ningún modelo lidera todos los benchmarks. Carbon puntúa más alto en Artificial Analysis Intelligence Index, Terminal-Bench 4.0, GraphWalks y evaluaciones de ciberseguridad, mientras que Claude Opus 5.5 lidera OSWorld-2.1 y FrontierSWE 2 en la comparación publicada por Google.
### What thinking levels does Gemini 4 Carbon support?
Gemini 4 Carbon soporta los niveles LOW, MEDIUM y HIGH, con MEDIUM como predeterminado. Los desarrolladores pueden usar estos ajustes para equilibrar profundidad de razonamiento, latencia y consumo de tokens.
### Can Gemini 4 Carbon process images, audio, and video?
Sí. Su model card lista texto, imágenes, audio y video como modalidades de entrada soportadas. La modalidad de salida documentada es texto.
### What is Gemini 4 Carbon's knowledge cutoff?
La model card de noviembre de 2026 de Google indica marzo de 2026 como su knowledge cutoff. Por lo tanto, el modelo puede carecer de conocimientos sobre eventos y desarrollos posteriores a esa fecha a menos que se proporcionen mediante herramientas externas o contexto aportado por el usuario.
