
A Gemini 4 Carbon API e a Gemini 4 Argon API recebem o mesmo pedido e custam o mesmo por token de entrada e de saída, por isso escolher entre elas é uma decisão de encaminhamento e não uma migração. No PoYo, mudas alterando uma única string: gemini-4-carbon (página do modelo) ou gemini-4-argon (página do modelo). Este artigo explica o que difere ao nível da API, o que as diferenças de benchmarks da Google dizem sobre os pedidos que pertencem ao Carbon e um router que podes integrar no teu código.
É a primeira vez que usas o Carbon? Começa pela visão geral da Gemini 4 Carbon API e pelo guia do primeiro pedido. Para o Argon por si só, vê o guia da Gemini 4 Argon API.
Gemini 4 Carbon API vs Gemini 4 Argon API num relance
| Gemini 4 Carbon | Gemini 4 Argon | |
|---|---|---|
| ID do modelo no PoYo | gemini-4-carbon | gemini-4-argon |
| Endpoints no PoYo | POST /v1/chat/completions, POST /v1beta/models/gemini-4-carbon:generateContent / :streamGenerateContent | Os mesmos dois formatos, com gemini-4-argon |
| Janela de contexto | 1M tokens | 1M tokens |
| Saída máxima por resposta | 64K tokens | Maior: a Google descreve um limite unificado de entrada e saída de 1M (vê o nosso guia do Argon) |
| Tipos de entrada | Texto, imagem, áudio, vídeo, PDF | Texto, imagem, áudio, vídeo, PDF |
| Posicionamento da Google | O modelo de raciocínio mais forte; gasta mais tokens para explorar, raciocinar e verificar | Modelo eficiente: respostas mais rápidas, menor gasto de tokens por turno |
| Orientação da Google | Programação com vários passos mais difícil, depuração, investigação em aberto | "A escolha ideal para a maioria do trabalho de engenharia de software e de conhecimento" |
A estrutura do pedido é idêntica. No Chat Completions, o ID do modelo vai no campo model; no Gemini Native, vai no caminho do URL. Ambos os modelos suportam streaming ("stream": true, ou :streamGenerateContent). Os erros também são os mesmos: 400 para campos inválidos ou um formato errado, 401 para uma chave inválida, 404 para um ID de modelo desconhecido e 402 quando os teus créditos se esgotam.
O único limite que obriga a um encaminhamento é o tamanho da saída. O teto documentado do Carbon é de 64K tokens de saída por resposta. Se uma única resposta tiver de ser mais longa do que isso (uma reescrita completa de vários ficheiros de uma só vez, por exemplo), envia-a para o Argon.
Diff de migração: o que muda no JSON
Passar um pedido do Argon para o Carbon no 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
}
No Gemini Native, só muda o caminho:
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) ou generationConfig.maxOutputTokens (Gemini Native) a 64 000 ou menos quando chamas o Carbon. Não é preciso mudar mais nada no corpo.
Preço por token: igual, exceto nas leituras de cache
Preços do PoYo, a partir das páginas atuais dos modelos (1 crédito = $0.005):
| Medidor (por 1M de tokens) | Gemini 4 Carbon no PoYo | Gemini 4 Argon no PoYo | Oficial da Google (ambos, introdutório) |
|---|---|---|---|
| Entrada | $1.60 (320 créditos) | $1.60 (320 créditos) | $2.00 |
| Saída (incl. thinking) | $8.00 (1,600 créditos) | $8.00 (1,600 créditos) | $10.00 |
| Leitura de cache | $0.08 (16 créditos) | $0.16 (32 créditos) | $0.10 (95% de desconto sobre a entrada) |
A Google lançou o Carbon ao preço introdutório do Argon. O seu artigo sobre a disponibilidade diz que o período introdutório termina a 30 de novembro de 2026 e que a partir de 1 de dezembro se aplicam $4 de entrada e $20 de saída por 1M de tokens. O artigo sobre os preços do Carbon compara ambas as tarifas da Google com o preço atual do PoYo.
A diferença está na linha da leitura de cache: no PoYo, as leituras de cache do Carbon custam metade das do Argon. Essa poupança é real, mas pequena. São $0.08 por 1M de tokens em cache, e 10 000 tokens de saída extra ($0.08 a $8.00 por 1M) anulam-na. Como a Google diz que o Carbon gasta mais tokens por tarefa do que o Argon, conta que o Carbon custe mais por tarefa na maioria das cargas de trabalho, mesmo com a cache mais barata.
Um exemplo prático com contagens de tokens idênticas (400K de leituras em cache, 50K de entrada nova, 20K de saída):
| 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 |
| Custo | $0.272 (54.4 créditos) | $0.304 (60.8 créditos) |
Se o Carbon precisar de 30K tokens de saída para a mesma tarefa em vez de 20K, custa $0.352. É por isso que deves medir o custo por tarefa concluída e não o custo por token. O script de medição está mais abaixo.
Diferenças de benchmarks como prova para o encaminhamento
Estes são os números da própria Google, da tabela de lançamento do Gemini 4 Carbon, por isso trata-os como a comparação do fornecedor e não como um teste independente. A coluna da diferença mostra-te onde os tokens extra compensam.
| Benchmark | Carbon | Argon | Diferença |
|---|---|---|---|
| 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ê-a como uma tabela de encaminhamento:
- Diferenças grandes: encaminha para o Carbon. Recuperação em contexto longo entre 256K e 1M tokens, trabalho de agentes conduzido pelo terminal, tarefas de agentes com vários passos e validação de exploits.
- Diferenças pequenas: mantém no Argon. Automação de negócio (+2,6), trabalho de conhecimento geral (Vals Index, +1,2) e geração de patches no CWE-bench (+3,0). Aqui, o Argon obtém a maior parte da pontuação gastando menos tokens por turno.
- Ressalva de cibersegurança. Os resultados de cibersegurança da Google refletem o acesso através do seu Fairwind Program, e o artigo sobre a disponibilidade diz que o Carbon para cibersegurança só é oferecido através desse programa. Não assumas que a API pública reproduz essas pontuações. Testa com as tuas próprias tarefas.
Compara pontuações apenas dentro de uma mesma tabela. O nosso guia do Argon cita a tabela de lançamento do Argon da Google, que indica 57,4% para o Argon no Terminal-Bench 4.0. A tabela do Carbon usa o harness da Artificial Analysis (57,1%).
Estratégia de encaminhamento: Argon por predefinição, escalar para o Carbon
A orientação da Google e as diferenças nos benchmarks apontam para o mesmo desenho:
- Envia todos os pedidos para
gemini-4-argonpor predefinição. - Encaminha os tipos de tarefa que sabes serem difíceis diretamente para
gemini-4-carbon: depuração em todo o repositório, agentes de terminal, perguntas sobre mais de 256K tokens de contexto e triagem de segurança. - Escala em caso de falha. Se a resposta do Argon falhar a tua verificação (testes, validação de esquema, um avaliador) ou parar com
finish_reason: "length", repete uma vez no Carbon. - Força o Argon quando a resposta tiver de ultrapassar os 64K tokens.
Este router usa o SDK da OpenAI apontado para o endpoint Chat Completions do PoYo. Envia apenas campos documentados: model, messages e 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 é o teu próprio teste de aceitação, por exemplo "o patch aplica-se e os testes passam" ou "o JSON é válido segundo o meu esquema". A estimativa de custo trata todos os tokens do prompt como entrada sem cache. Os campos de uso documentados do PoYo não discriminam os tokens em cache, por isso isto é um limite superior.
Mede tu próprio o custo por tarefa
Os preços por token são iguais, por isso o único número que separa as duas APIs é o custo por tarefa aceite. Regista cada tentativa de run():
| Campo a registar | Origem no Chat Completions | Origem no Gemini Native |
|---|---|---|
| Modelo efetivamente usado | model | Caminho do URL |
| Tokens de entrada | usage.prompt_tokens | usageMetadata.promptTokenCount |
| Tokens de saída | usage.completion_tokens | usageMetadata.candidatesTokenCount + thoughtsTokenCount |
| Atingiu o limite de saída | finish_reason == "length" | finishReason |
| Passou a tua verificação | o teu avaliador | o teu avaliador |
A Google cobra a saída incluindo os tokens de thinking, por isso no Gemini Native conta thoughtsTokenCount como saída. Com streaming, o último chunk do Chat Completions traz usage. Depois, por tipo de tarefa:
cost per accepted task = sum(cost_usd of all attempts, incl. escalations) / tasks that passed
Corre uma semana de tráfego real com o Argon por predefinição e compara com uma amostra enviada diretamente para o Carbon. Se o Carbon passar tarefas para as quais o Argon precisou de escalamento, acrescenta esse tipo de tarefa a CARBON_TASKS. Se a taxa de aprovação do Carbon num tipo for igual à do Argon, mantém esse tipo no Argon. Compara o teu painel do PoYo com o teu registo nas primeiras centenas de chamadas.
Se também estiveres a ponderar modelos de outros fornecedores, vê Gemini 4 Carbon API vs Claude Opus 5.5 API vs GPT-6 Astra API. Para um ciclo de agente com proteções de orçamento, vê Gemini 4 Carbon API para agentes de programação.
Perguntas frequentes
A Gemini 4 Carbon API é mais cara do que a Gemini 4 Argon API?
Não por token. Ambas custam $1.60 de entrada e $8.00 de saída por 1M de tokens no PoYo, e $2.00 / $10.00 no preço introdutório da Google. No PoYo, a leitura de cache do Carbon é mais barata ($0.08 vs $0.16 por 1M). Por tarefa, o Carbon costuma custar mais, porque a Google diz que usa mais tokens para raciocinar e verificar.
Como passo da Gemini 4 Argon API para a Gemini 4 Carbon API?
Muda "model": "gemini-4-argon" para "model": "gemini-4-carbon" no Chat Completions, ou muda o modelo no caminho do URL do Gemini Native. Mantém max_tokens em 64 000 ou menos para o Carbon.
Qual é a saída máxima da Gemini 4 Carbon API em comparação com o Argon?
O Carbon devolve até 64K tokens de saída por resposta, com uma janela de contexto de 1M de tokens. O Argon permite respostas individuais muito mais longas, por isso encaminha as saídas acima de 64K para o Argon.
Devo usar o Gemini 4 Argon ou o Gemini 4 Carbon para programar?
A Google diz que o Argon continua a ser a escolha ideal para a maioria da engenharia de software. Usa o Carbon para a depuração com vários passos mais difícil e para o trabalho de agentes conduzido pelo terminal, onde a tabela da Google mostra as maiores diferenças: Terminal-Bench 4.0 (AA) 65,2% vs 57,1%, e SWE-sweep 9,6% vs 4,3%.
O Gemini 4 Carbon e o Argon usam o mesmo endpoint da API?
Sim. Ambos funcionam com POST https://api.poyo.ai/v1/chat/completions (compatível com a OpenAI) e POST https://api.poyo.ai/v1beta/models/{model}:generateContent ou :streamGenerateContent (Gemini Native), com a mesma chave de API do PoYo.