Construa com CometAPIPrecisa de uma API para vários modelos?Teste o fluxo no Playground e depois crie uma chave da API quando o modelo e o custo atenderem ao seu caso de uso.
Use Gemini 4 Carbon API no CometAPI para adicionar raciocínio e análise de documentos ao seu aplicativo através da interface nativa GenerateContent do Gemini. Comece com uma solicitação curta de texto, verifique se a geração foi concluída e salve a resposta antes de adicionar PDF, imagens, streaming ou JSON estruturado. Este guia fornece a configuração e o código de tratamento de resposta para cada etapa.
Principais pontos
Model ID: gemini-4-carbon. Sem camada gratuita — requer Gemini API paga / Cloud Billing.
Janela unificada de 1M tokens (entrada + raciocínio + saída). Saída máxima padrão ~65K; decodificação longa estende para quase 1M.
Níveis de raciocínio: (rápido/barato), (padrão, equilibrado), (raciocínio profundo).
Revisado para maior clareza, atribuição de fontes e terminologia de API atual.
low
medium
high
Preço introdutório até 30 de nov. de 2026: $2 / $10 por 1M tokens (entrada em cache $0,10). Dobra em 1º de dez.
Excelente para codificação agentiva de longo horizonte, raciocínio científico, trabalho do conhecimento e tarefas de cibersegurança.
SDKs oficiais (google-genai) + endpoints compatíveis com OpenAI disponíveis.
CometAPI oferece o acesso de produção mais simples com uma única chave, tarifas competitivas e comutação transparente entre Gemini 4 Carbon, Claude e 500+ outros modelos.
Arte de lançamento do Gemini 4 Carbon. Imagem: Google. Arte original.
O que é o Gemini 4 Carbon API?
Gemini 4 Carbon é o modelo de fronteira de raciocínio da Google para fluxos de trabalho agentivos de longo horizonte, engenharia de software complexa, cibersegurança e pesquisa científica. Construído sobre o Gemini 4 Argon, ele utiliza raciocínio mais profundo e ciclos de verificação estendidos para enfrentar tarefas de múltiplas etapas que exigem solução de problemas sustentada, em vez de uma única resposta. Comparado ao Argon, o Carbon é projetado para workloads mais exigentes, onde precisão e conclusão da tarefa importam mais do que minimizar o uso de tokens. A Google anunciou acesso pago para desenvolvedores em 10 de novembro de 2026. Seu suporte multimodal de entrada permite combinar texto com entradas visuais e outras mídias; a saída gerada é texto. O CometAPI oferece acesso à API com desconto.
Para uma integração de API, comece com uma tarefa cujo resultado você possa verificar: resumir um documento, extrair campos de uma nota de incidente ou revisar uma captura de tela. Um fluxo de trabalho agentivo mais amplo pode se basear nessa solicitação funcionando depois que você tiver verificado as ferramentas suportadas da rota e o comportamento da resposta.
Outras formas de usar
Google AI Studio Playground: selecione o modelo e teste prompts de forma interativa (requer acesso pago para o Carbon).
Gemini app / AI Mode / Antigravity: disponível se você tiver Google AI Ultra (selecione o modelo onde oferecido).
Enterprise / Cloud: use via Gemini Enterprise Agent Platform ou endpoints estilo Vertex com o mesmo ID de modelo (configuração de projeto + localização).
Cientistas/pesquisadores podem solicitar acesso gratuito limitado em alguns casos.
Quais são as especificações do Gemini 4 Carbon API?
As especificações oficiais do modelo distinguem o orçamento de contexto compartilhado do limite de saída de cada segmento em primeiro plano. Estes são limites ao nível do modelo; seu gateway também pode aplicar restrições de tamanho de solicitação e recursos.
Limitações e considerações de API
Antes de expandir sua integração, verifique como o Carbon lida com contexto, configurações de geração, cache e acesso. A tabela associa cada restrição a uma ação prática para evitar solicitações inválidas, resultados incompletos e custos inesperados.
Área
Limitação ou requisito
Implicação para o desenvolvedor
Orçamento unificado de tokens
Entrada e saída compartilham 1.048.576 tokens, incluindo raciocínio e chamadas de função.
Reserve espaço de saída antes de adicionar histórico de conversa ou arquivos.
Decodificação longa
Um segmento em primeiro plano permite até 65.536 tokens de saída ao fazer streaming, ou 32.768 sem streaming;
gerações mais longas precisam de continuação.
Níveis de raciocínio
Low, Medium, High; Medium é o padrão
Para GenerateContent, envie LOW, MEDIUM ou HIGH; MINIMAL é rejeitado.
Orçamento de raciocínio
Parâmetro legado thinking_budget é rejeitado
Remova thinking_budget dos construtores de requisição e use thinking_config.thinking_level em Python, ou thinkingConfig.thinkingLevel no JSON REST.
Amostragem
Valores personalizados de temperature, top_p e top_k são ignorados
Use thinking_level para selecionar a profundidade do raciocínio e response_schema para saída estruturada.
Cache de contexto
Cache implícito é suportado; criação explícita de cache de contexto não é.
Coloque o contexto reutilizável primeiro e a pergunta variável por último. Remova chamadas de criação explícita de cache e referências a cached_content.
Custo de API
Tokens de raciocínio são faturados como saída
Conte o raciocínio assim como a saída visível.
Acesso de cibersegurança
Acesso cibernético especializado é restrito
Verifique elegibilidade para acesso Fairwind especializado. O acesso padrão ao Carbon por si só não concede acesso à variante ciber-permissiva.
Confiabilidade
O guia do desenvolvedor do Carbon documenta as regras da API; seu model card descreve confiabilidade e limitações de acesso especializado. Confirme os recursos correspondentes na sua rota do CometAPI antes de habilitá-los em produção.
Níveis de raciocínio: como escolher a configuração certa
Comece com MEDIUM, depois ajuste o nível para a tarefa e a qualidade que você precisa.
LOW: Use para extração, classificação e resumos simples quando tempo de resposta e custo são prioridades. Experimente em tarefas como rotular chamados de suporte e verifique se ainda atende sua meta de precisão.
MEDIUM: Use este ponto de partida padrão para codificação do dia a dia, análise de documentos e raciocínio rotineiro. É uma base prática para avaliar se um nível diferente melhora seu aplicativo.
HIGH: Use para depuração complexa, pesquisa em múltiplas etapas e raciocínio científico que se beneficiam de investigação mais profunda. Considere tokens adicionais de raciocínio e mantenha-o apenas quando o ganho de qualidade justificar o custo e o tempo adicionais.
Níveis mais altos de raciocínio não garantem automaticamente melhores resultados para toda tarefa. Faça benchmark dos seus próprios workloads e compare qualidade de conclusão, latência e uso total de tokens antes de alterar padrões de produção.
Como o Gemini 4 Carbon se sai em benchmarks de IA?
Resultados de benchmarks selecionados
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%
As páginas Artificial Analysis Carbon (High) e Argon (High) mostram o seguinte instantâneo, verificado em 12 de novembro de 2026. Esses são resultados de benchmark, não medições de latência do CometAPI.
Métrica
Carbon (High)
Argon (High)
Intelligence Index
60
50
Velocidade de saída
80 tokens/s
65 tokens/s
Tempo até o primeiro token de resposta
67,83 s
37,64 s
Tempo por tarefa do Intelligence Index
25,5 min
30,0 min
Tokens de saída ao longo da avaliação
205M
113M
Custo por tarefa do Intelligence Index
$7,76
$9,95
Os totais de tokens de saída cobrem a avaliação, não uma única solicitação. O custo por tarefa usa pressupostos de preços do Artificial Analysis em vez do desconto atual do CometAPI. O Carbon espera mais antes do primeiro token de resposta, mas conclui a tarefa de benchmark mais rápido e com menor custo relatado; volume de tokens sozinho não determina valor.
Use o Carbon quando sua verificação mais profunda melhora revisão de código difícil, pesquisa ou outro trabalho caro de errar. Teste o Argon para codificação e tarefas de conhecimento rotineiras, mas confirme as economias no seu próprio workload. Execute prompts idênticos e compare gasto total dividido por resultados aceitos, junto com tempo de conclusão e taxa de falhas.
Como começar com o Gemini 4 Carbon API no CometAPI?
Você precisará de uma conta no CometAPI com acesso ao modelo e crédito suficiente, um ambiente Python e familiaridade básica com execução de scripts. Use um diretório de projeto para os arquivos abaixo, assim cada exemplo pode importar a mesma configuração de cliente.
Por que usar o Gemini 4 Carbon API via CometAPI?
O CometAPI é útil quando você deseja avaliar o Carbon ao lado de outros modelos, gerenciando acesso e faturamento por um único provedor. Sua rota do Carbon oferece tanto GenerateContent nativo do Gemini quanto uma interface Chat compatível com OpenAI, para que você escolha o formato de requisição que se ajusta ao seu aplicativo.
Para este guia, a rota nativa permite reutilizar o Google Gen AI SDK com uma chave e base URL do CometAPI. Os preços atuais do grupo padrão estão 20% abaixo das tarifas introdutórias da Google. Mantenha o ID do modelo na configuração para comparar o Carbon e o Argon sem reescrever seu aplicativo, e verifique o suporte específico da rota antes de adicionar ferramentas, uploads de arquivo ou continuações longas.
Etapa 1: crie sua conta e defina sua chave de API
Acesse o CometAPI, crie ou abra sua chave de API e armazene-a como uma variável de ambiente. Evite colocar chaves diretamente no código-fonte ou comitá-las no repositório.
Use o comando para seu shell. Defina as variáveis no mesmo terminal em que você executará o Python; substitua o placeholder pela sua própria chave.
Instale o SDK no ambiente do seu projeto. Usar python -m pip mantém o instalador vinculado ao interpretador que executará o exemplo.
Instale ou atualize o Google Gen AI SDK.
python -m pip install --upgrade google-genai
O CometAPI documenta um endpoint nativo do Gemini com uma base URL personalizada para o SDK. Use sua chave do CometAPI para este endpoint. As configurações abaixo se aplicam a solicitações GenerateContent.
Configuração
Valor
SDK
google-genai
Base URL
https://api.cometapi.com
Versão da API
v1beta
Cabeçalho de autenticação REST
x-goog-api-key
Variável de ambiente da chave
COMETAPI_KEY
Variável de ambiente do modelo
COMETAPI_MODEL
Model ID
gemini-4-carbon
Etapa 3: crie um cliente reutilizável e valide respostas
Salve esta configuração como carbon_client.py. Ele define o cliente uma vez e fornece completed_text para as respostas somente texto usadas neste guia. O helper verifica o motivo de término do candidato antes de retornar o texto da resposta, para que um resultado vazio ou truncado não seja tratado silenciosamente como sucesso.
Crie carbon_client.py com o cliente do CometAPI e um validador de respostas 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
Etapa 4: envie sua primeira solicitação e verifique o resultado
Crie first_request.py ao lado de carbon_client.py e adicione o código abaixo. Ele envia um prompt curto de checklist usando raciocínio MEDIUM e um orçamento de saída de 4.096 tokens, verifica a conclusão com completed_text(response) e salva a resposta em answer.txt como UTF-8. Execute python first_request.py no diretório do projeto, depois abra answer.txt e confirme que todos os cinco pontos de revisão são relevantes e utilizáveis. Verifique os metadados de uso impressos para consumo de tokens, incluindo raciocínio; um término normal não estabelece a qualidade da resposta. Se a solicitação falhar ou retornar saída incompleta, use a seção de solução de problemas para verificar credenciais, detalhes do erro e o motivo de término antes de tentar novamente.
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
## Como o Gemini 4 Carbon pode analisar arquivos?
Execute estes exemplos no mesmo diretório que carbon_client.py. Eles carregam arquivos locais em partes de conteúdo inline, mantendo o fluxo inicial independente de um serviço separado de upload de arquivos.
A compreensão de PDF inclui conteúdo visual: o Gemini pode interpretar texto, tabelas, gráficos e imagens em conjunto. O [guia de processamento de documentos da Google](https://ai.google.dev/gemini-api/docs/document-processing) descreve suporte a PDFs de até 1.000 páginas, sujeito a limites de tamanho de arquivo e contexto. A contagem de páginas é um teto, não uma garantia de que todo documento caberá numa requisição do gateway.
Use entrada inline para PDFs pequenos e temporários. Para arquivos maiores ou perguntas multi-turnos repetidas, a Google recomenda a Files API para evitar reenviar o arquivo completo. Antes de usar esse fluxo através do CometAPI, verifique seu endpoint de upload e suporte a referências de arquivo; o exemplo inline abaixo continua sendo um ponto de partida prático.
### Resumir um PDF local
A Google documenta [entrada inline de PDF](https://ai.google.dev/gemini-api/docs/document-processing) para GenerateContent. Coloque um report.pdf pequeno e não sensível no diretório do projeto, depois salve o seguinte como analyze_pdf.py e execute python analyze_pdf.py.
Envie um PDF local e salve seu resumo concluído.
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),
)
Verifique o resumo em relação ao arquivo antes de expandir para documentos maiores. Limites de tamanho de solicitação e suporte a referências de arquivo dependem do gateway. O suporte da Google a formatos do Office ou referências ao Cloud Storage não estabelece por si só suporte a essas entradas através da sua rota do CometAPI.
### Revisar uma captura de tela local
Para [entrada inline de imagem](https://ai.google.dev/gemini-api/docs/image-understanding), combine o MIME type ao arquivo. Coloque uma captura de tela PNG chamada screen.png ao lado do script. Salve este exemplo como analyze_image.py e execute python analyze_image.py para revisar texto visível e layout.
Analise uma captura de tela PNG sem depender de uma URL pública de imagem.
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))
Compare cada problema relatado com a captura de tela. Se você enviar um JPEG, altere tanto o nome do arquivo quanto o MIME type para corresponder; mudar apenas a extensão não converte a imagem.
## Como fazer streaming de respostas do Gemini 4 Carbon?
### Exibir texto em streaming e verificar conclusão
O streaming retorna partes de resposta como server-sent events (SSE), permitindo que um aplicativo exiba saída parcial enquanto a geração continua.
O SDK expõe [geração de texto em streaming](https://ai.google.dev/gemini-api/docs/text-generation) através de generate_content_stream. Para requisições HTTP diretas, o CometAPI usa streamGenerateContent com alt=sse.
Salve o seguinte como stream_response.py e execute python stream_response.py. Ele exibe o texto conforme chega, depois verifica se o stream terminou com um motivo de término normal. Uma exceção deixa o texto exibido como resultado parcial, não uma resposta aceita.
Leia texto em streaming e exija término normal antes de aceitá-lo.
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}")
### Extrair JSON estruturado
Para [saída restrita por esquema](https://ai.google.dev/gemini-api/docs/structured-output), solicite application/json e defina os campos que seu aplicativo espera. Este exemplo extrai dois campos de uma nota curta de incidente e então verifica seus tipos antes de imprimir o resultado.
Salve este exemplo como structured_output.py e execute python structured_output.py. Ele reutiliza o validador de resposta antes de fazer o parse do JSON.
Extraia campos de incidente, verifique a conclusão e valide seus 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))
Você deve receber um objeto contendo service e impact. Conformidade com o esquema não estabelece precisão factual: compare os valores extraídos com a entrada e aplique quaisquer regras de negócio antes de armazenar ou agir sobre o resultado.
## Preço do Gemini 4 Carbon API
Os [preços introdutórios da Google](https://blog.google/innovation-and-ai/models/gemini-4-carbon-now-available/) vão até 30 de novembro de 2026; suas tarifas padrão entram em vigor em 1º de dezembro. Verifique as tarifas atuais da sua conta antes de orçar solicitações posteriores.
Ambos os modelos pertencem à família Gemini 4, mas visam workloads diferentes.
| Camada de preços da API | Entrada / 1M tokens | Saída / 1M tokens |
| --------------------------- | ------------------- | ----------------- |
| Standard (até 30 de nov.) | $2,00 | $10,00 |
| Standard (a partir de 1º de dez.) | $4,00 | $20,00 |
| Batch (até 30 de nov.) | $1,00 | $5,00 |
| Batch (a partir de 1º de dez.) | $2,00 | $10,00 |
| Flex (até 30 de nov.) | $1,00 | $5,00 |
| Priority (até 30 de nov.) | $3,60 | $18,00 |
Detalhes adicionais de preços:
* Entrada em cache: $0,10 por milhão de tokens até 30 de novembro, aumentando para $0,20 a partir de 1º de dezembro.
* Batch e Flex oferecem processamento de menor custo para workloads que toleram suas características de serviço.
* Tokens de raciocínio são faturados como tokens de saída.
* Tokens consumidos por instruções internas de ferramentas e declarações de funções também podem ser faturáveis.
A Google recomenda explicitamente o Argon para a maioria dos trabalhos de engenharia de software e conhecimento, reservando o Carbon para tarefas que exigem raciocínio mais profundo e verificação estendida.
Recomendação prática: escolha o Carbon quando o custo de um resultado incorreto for alto ou quando a tarefa exigir exploração e verificação substanciais. Escolha o Argon quando você precisar de forte raciocínio com um orçamento de tokens mais eficiente.
### Preço no CometAPI
Conforme verificado em 12 de novembro de 2026, a [tabela do grupo padrão do CometAPI](https://www.cometapi.com/models/google/gemini-4-carbon/) lista $1,60 por milhão de tokens de entrada, $8,00 por milhão de tokens de saída incluindo raciocínio, e $0,08 por milhão de tokens de entrada em cache em acertos de cache. Essas tarifas são 20% abaixo das tarifas introdutórias correspondentes da Google.
Os preços do CometAPI podem mudar à medida que as tarifas oficiais da Google mudarem. Compare a tarifa oficial atual com o desconto associado à sua conta em vez de tratar o preço em dólares de hoje como permanente. Se o mesmo desconto de 20% for mantido após uma mudança de tarifa, sua tarifa é a nova tarifa oficial × 0,80; confirme a tarifa real do CometAPI antes de orçar. Outros grupos de conta podem ter descontos diferentes.
Para uma solicitação com 100.000 tokens de entrada não em cache e 10.000 tokens de saída, incluindo raciocínio, o custo apenas de tokens é $0,24 na tarifa exibida do CometAPI: $0,16 pela entrada mais $0,08 pela saída. As mesmas quantidades custam $0,30 nas tarifas introdutórias da Google ou $0,60 nas tarifas de dezembro. Os 110.000 tokens combinados cabem no orçamento compartilhado do modelo.
Esta estimativa exclui ferramentas, novas tentativas e quaisquer ajustes de preço específicos da conta. O custo de saída inclui tokens de raciocínio, então um nível mais alto de raciocínio pode aumentar a conta mesmo que a resposta visível seja curta.
### Como otimizar custos do Gemini 4 Carbon API?
Otimize para o custo de um resultado correto e utilizável. Uma solicitação mais barata tem pouco valor se você precisar repeti-la ou corrigir manualmente a resposta.
1. Escolha o raciocínio deliberadamente. Comece em MEDIUM, teste LOW para trabalho simples e use HIGH quando aumentar a taxa de aceitação o suficiente para justificar o tempo e os tokens adicionais.
2. Reutilize contexto estável via cache implícito. Os fluxos do [Argon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-argon) e [Carbon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-carbon) não suportam criação explícita de cache de contexto; eles suportam cache implícito. Coloque instruções e documentos reutilizáveis primeiro, seguidos pela pergunta variável. A Google documenta elegibilidade para prefixos compartilhados de pelo menos 4.096 tokens. Verifique acertos e cobranças de cache na sua rota do CometAPI; repetição não garante desconto.
3. Reduza trabalho desnecessário. Envie páginas ou trechos relevantes, solicite apenas os campos de saída de que precisa e defina um orçamento de saída suficiente. O raciocínio conta para o uso de saída, então um teto muito baixo pode causar truncamento e novas tentativas.
4. Meça o fluxo de trabalho inteiro. Inclua raciocínio, uso de ferramentas, novas tentativas e respostas rejeitadas no gasto total. Salve respostas válidas para que falhas de armazenamento downstream não disparem outra geração.
5. Direcione pela medida de valor. Compare Carbon e Argon em tarefas idênticas. Considere Batch ou Flex apenas quando seu provedor os suportar e o workload puder tolerar suas características.
Acompanhe custo por resultado aceito = gasto total do fluxo de trabalho ÷ resultados aceitos. Revise isso junto com latência e qualidade após mudar um modelo, prompt ou nível de raciocínio.
## Qual formato de API usar para o Gemini 4 Carbon?
Desenvolvedores podem acessar o [Gemini 4 Carbon API no CometAPI](https://www.cometapi.com/models/google/gemini-4-carbon/) via a API nativa do Gemini e uma API Chat compatível com OpenAI. Use a interface que corresponde ao formato de requisição do seu aplicativo e aos requisitos de recursos documentados.
| Interface | Quando se encaixa | Verificação de integração |
| ----------------------------- | ------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------- |
| Gemini-native GenerateContent | Os exemplos em Python e REST deste guia; aplicativos que já usam contents e generationConfig | Use a base URL do Gemini e os nomes de campos mostrados acima |
| OpenAI-compatible Chat API | Um aplicativo existente organizado em torno de mensagens de chat | Verifique endpoint, campos e recursos suportados da rota do Carbon antes de adaptar o código |
A compatibilidade se aplica a um endpoint e formato de requisição específicos. Não envie campos de OpenAI Responses ao endpoint nativo do Gemini, nem presuma que uma rota compatível com Chat também implementa Responses. Um aplicativo habilitado para ferramentas precisa de um caminho verificado desde a chamada de função até o resultado correspondente, não apenas um prompt de texto bem-sucedido.
## Como migrar do Gemini 4 Argon para o Gemini 4 Carbon API?
Se seu aplicativo Argon já usa a rota Gemini-native GenerateContent do CometAPI, comece trocando o modelo configurado para gemini-4-carbon. Mantenha a chave, base URL, prompt e lógica de validação inalterados para a primeira comparação. Tanto o [Argon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-argon) quanto o [Carbon](https://docs.cloud.google.cn/gemini-enterprise-agent-platform/models/guides/gemini-4-carbon) compartilham muitas convenções de requisição do Gemini 4; limpeza de parâmetros legados só é necessária se esses campos permanecerem no seu aplicativo.
### 1. Altere o modelo e execute uma comparação controlada
Na configuração usada neste guia, mude COMETAPI_MODEL de gemini-4-argon para gemini-4-carbon, então reinicie o processo Python para recarregar a variável. Use o mesmo prompt representativo e nível de raciocínio para ambos os modelos. O exemplo standalone abaixo reutiliza carbon_client.py e seleciona explicitamente o 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. Verifique configurações de requisição e histórico de conversa
Mantenha LOW, MEDIUM ou HIGH no GenerateContent. Remova quaisquer resíduos de thinking_budget, MINIMAL ou uso explícito de cached_content. Não dependa de temperature, top_p ou top_k para controlar o resultado. Remova frequency_penalty, presence_penalty e valores de candidate_count acima de 1. Se você chamar ferramentas, preserve IDs, nomes e ordem de resposta correspondentes às chamadas de função. Estas são verificações de compatibilidade, não recursos recém-removidos do Argon.
### 3. Valide qualidade, custo e latência antes do rollout
Execute o mesmo conjunto de testes em ambos os modelos. Verifique sucesso da tarefa, validação de JSON, execução de ferramentas, conclusão completa, tokens faturados e tempo decorrido. Mantenha a configuração do Argon disponível, direcione uma pequena porção do tráfego ao Carbon, e expanda apenas se ele atender suas metas de aceitação e orçamento.
### 4. Mantenha o suporte a saídas longas separado da troca de modelo
Comece com solicitações que terminam em um único segmento em primeiro plano. Se você precisar de continuação, primeiro confirme que o CometAPI suporta o endpoint e os campos de resposta necessários. Uma mudança apenas no nome do modelo não habilita o workflow de continuação v1beta1 da Google no gateway v1beta deste guia. Mantenha a saída parcial incompleta até que a geração termine normalmente.
## Conclusão
Use a primeira solicitação bem-sucedida como ponto de partida para um teste de integração. Adicione apenas os tipos de entrada e formatos de resposta de que seu aplicativo precisa, depois verifique saídas completas, tratamento de erros e custo em tarefas representativas. Direcione uma pequena parcela do tráfego pela nova integração antes de expandi-la, e mantenha uma configuração conhecida e funcional disponível se os resultados mudarem.
## Gemini 4 Carbon FAQ
### Qual é o tamanho da janela de contexto do Gemini 4 Carbon?
O Gemini 4 Carbon suporta um limite unificado de contexto de entrada e saída de 1.048.576 tokens. Esse orçamento inclui entrada, raciocínio, chamadas de função e saída gerada.
### Quais são os benchmarks mais fortes do Gemini 4 Carbon?
Seus resultados de destaque relatados incluem 88,2% no SEC-bench Pro, 54,8% no ExploitGym, 71,0% no CWE-bench e 96,2% no GraphWalks. Esses resultados destacam suas capacidades em cibersegurança, contexto longo e raciocínio agentivo.
### Como o Gemini 4 Carbon se compara ao Gemini 4 Argon?
O Carbon melhora substancialmente sobre o Argon em vários benchmarks relatados, incluindo Artificial Analysis Intelligence Index (59 vs. 50), SWE-sweep (9,6% vs. 4,3%) e SEC-bench Pro (88,2% vs. 83,4%). Sua distinção principal é desempenho mais forte em raciocínio estendido e tarefas agentivas complexas.
### O Gemini 4 Carbon é melhor que o Claude Opus 5.5?
Nenhum modelo lidera todos os benchmarks. O Carbon pontua mais alto em Artificial Analysis Intelligence Index, Terminal-Bench 4.0, GraphWalks e avaliações de cibersegurança, enquanto o Claude Opus 5.5 lidera OSWorld-2.1 e FrontierSWE 2 na comparação publicada pela Google.
### Quais níveis de raciocínio o Gemini 4 Carbon suporta?
O Gemini 4 Carbon suporta os níveis LOW, MEDIUM e HIGH, com MEDIUM como padrão. Desenvolvedores podem usar essas configurações para equilibrar profundidade de raciocínio, latência e consumo de tokens.
### O Gemini 4 Carbon pode processar imagens, áudio e vídeo?
Sim. Seu model card lista texto, imagens, áudio e vídeo como modalidades de entrada suportadas. Sua modalidade de saída documentada é texto.
### Qual é o knowledge cutoff do Gemini 4 Carbon?
O model card de novembro de 2026 da Google lista março de 2026 como knowledge cutoff. Portanto, o modelo pode não conhecer eventos e desenvolvimentos posteriores a essa data, a menos que sejam fornecidos via ferramentas externas ou contexto fornecido pelo usuário.
Podem ocorrer alucinações, timeouts ocasionais e uso maior de tokens
