DEV Community: Lucas

Preço do Gemini 4 Hydrogen: US$ 1,50 na entrada e US$ 7,50 na saída, tarifas fixas até 1 milhão de tokens

Lucas — Fri, 13 Nov 2026 07:59:53 +0000

Preços do Gemini 4 Hydrogen: quanto custa por 1M de tokens?

O Gemini 4 Hydrogen custa US$ 1,50 por 1M de tokens de entrada e US$ 7,50 por 1M de tokens de saída no nível pago Standard da API Gemini, um preço fixo em toda a janela de contexto de 1M de tokens. Tokens de thinking são cobrados na tarifa de saída, a entrada em cache custa US$ 0,075 por 1M, e Batch ou Flex reduzem todas as tarifas pela metade.

Experimente o Apidog hoje

O Hydrogen, lançado em 12 de novembro de 2026, é o membro rápido da família Gemini 4. Diferente do Carbon e do Argon, ele não tem um preço introdutório que dobra depois, e está disponível no nível Free. Abaixo: a tabela de preços, exemplos de custo calculados, como os níveis de thinking afetam sua fatura e como medir o seu próprio custo. Novo no modelo? Comece com o que é o Gemini 4 Hydrogen.

Quanto custa o Gemini 4 Hydrogen por 1M de tokens?

O Gemini 4 Hydrogen (ID do modelo gemini-4-hydrogen) tem quatro níveis pagos na página de preços do Google. Todos os preços são por 1M de tokens:

Nível	Entrada	Saída incl. thinking	Entrada em cache	Nível gratuito
Standard	US$ 1,50	US$ 7,50	US$ 0,075	Gratuito
Batch	US$ 0,75	US$ 3,75	US$ 0,0375	Indisponível
Flex	US$ 0,75	US$ 3,75	US$ 0,0375	Indisponível
Priority	US$ 2,70	US$ 13,50	US$ 0,135	Consulte a página de preços

Três detalhes na mesma página impactam seu orçamento:

Thinking é cobrado. "Cada token processado pelo modelo é contabilizado e cobrado, incluindo os tokens de thinking."
Apenas cache implícito. O cache explícito não é suportado; você obtém a tarifa de cache quando o cache implícito do Google identifica um prefixo de prompt repetido.
Grounding custa extra. O grounding com o Google Search inclui 5.000 solicitações gratuitas por mês; depois, US$ 14 por 1.000.

O uso no nível gratuito está marcado como "Usado para melhorar nossos produtos: Sim" na página. Nosso guia do Gemini 4 Hydrogen gratuito detalha todas as rotas com custo zero.

O que significa "preço fixo até 1M de tokens"?

Significa um único preço para qualquer tamanho de prompt. O post de lançamento do Google afirma que o Hydrogen "é cobrado com preço fixo em toda a sua janela de contexto de 1 milhão de tokens, a US$ 1,50 por milhão de tokens de entrada e US$ 7,50 por milhão de tokens de saída". Um prompt de 5K tokens e um de 900K tokens são cobrados pela mesma tarifa por token.

Nem todo modelo Gemini funciona assim: o Gemini 3.1 Pro Preview cobra US$ 2,00/US$ 12,00 por 1M até 200K tokens e US$ 4,00/US$ 18,00 acima disso.

Dois números deixam isso concreto:

Um prompt de 900K tokens (uma base de código grande ou uma pilha de PDFs) custa US$ 1,35 de entrada no Standard, ou US$ 0,0675 quando o cache implícito é acionado.
A janela de contexto é unificada: entrada, thinking e saída compartilham 1.048.576 tokens. Um prompt de 900K deixa cerca de 148K tokens para thinking e resposta combinados.

As respostas síncronas têm limite de 65.536 tokens. Saídas mais longas rodam via long decode, ainda a US$ 7,50 por 1M.

Como os níveis de thinking afetam sua fatura do Gemini 4 Hydrogen?

O Hydrogen oferece quatro níveis de thinking: low, medium, high (o padrão) e um novo xhigh. Você o define com generation_config.thinking_level. O preço por token nunca muda; o que muda é a quantidade de tokens de thinking, e eles são cobrados na tarifa de saída.

A Artificial Analysis executou seu Intelligence Index em cada nível. Veja o que ela relatou:

Nível de thinking	Pontuação no índice	Tokens gerados no índice	Custo por tarefa do índice
low	27	20,3M	US$ 0,29
medium	41	54,4M	US$ 0,80
high (padrão)	51	110M	US$ 1,87
xhigh	54	304M	US$ 3,16

Leia a tabela como proporções. Ir de high para xhigh gerou cerca de 2,8x mais tokens e elevou o custo por tarefa em cerca de 1,7x, para ganhar 3 pontos a mais no índice. Reduzir de high para low cortou os tokens para menos de um quinto.

A página What's new in Gemini 4 Hydrogen do Google adverte que o xhigh "pode causar overthinking em prompts mais simples" e recomenda escolher "o menor thinking_level que atenda ao seu padrão de qualidade". Note que o max_output_tokens limita thinking e saída combinados.

Quanto custa uma chamada do Gemini 4 Hydrogen?

Cada solicitação segue uma única fórmula. Pegue as contagens de tokens no objeto usage da resposta (total_input_tokens, total_cached_tokens, total_thought_tokens, total_output_tokens):

cost = (uncached_input x $1.50 / 1M)
     + (cached_input   x $0.075 / 1M)
     + ((thought + output) x $7.50 / 1M)

Os dois exemplos abaixo usam contagens de tokens ilustrativas, não medições reais. Substitua pelos seus próprios valores.

Exemplo 1: uma chamada de chat em high. 2.000 tokens de entrada, 1.500 tokens de thinking, 600 tokens de saída.

Linha	Standard	Batch ou Flex
Entrada (2.000)	US$ 0,0030	US$ 0,0015
Thinking + saída (2.100)	US$ 0,0158	US$ 0,0079
Total por chamada	US$ 0,0188	US$ 0,0094
10.000 chamadas por mês	US$ 187,50	US$ 93,75

Exemplo 2: um loop de agente. Um agente de código executa 40 turnos. Ele reenvia a conversa a cada turno, então lê 1,2M de tokens de entrada no total, sendo que 900K desses acionam o cache implícito. Ele usa 200K tokens de thinking e escreve 60K tokens de código e chamadas de ferramentas.

Linha	Standard	Batch ou Flex	Priority
Entrada sem cache (300K)	US$ 0,45	US$ 0,23	US$ 0,81
Entrada em cache (900K)	US$ 0,07	US$ 0,03	US$ 0,12
Thinking + saída (260K)	US$ 1,95	US$ 0,98	US$ 3,51
Total por execução	US$ 2,47	US$ 1,23	US$ 4,44

Cerca de 79% da fatura no Standard vem de thinking e saída, então o nível de thinking importa mais do que encurtar seu prompt. O código das solicitações de ambos os exemplos está no nosso guia da API do Gemini 4 Hydrogen.

Como o preço do Hydrogen se compara com Carbon, Argon e Gemini 3.8 Flash?

Aqui estão as tarifas do nível pago Standard por 1M de tokens da página de preços do Google, consultadas em 13 de novembro de 2026:

Modelo	Entrada	Saída	Entrada em cache	Nível gratuito
Gemini 4 Hydrogen	US$ 1,50	US$ 7,50	US$ 0,075	Sim
Gemini 4 Carbon (até 30/11)	US$ 2,00	US$ 10,00	US$ 0,10	Não
Gemini 4 Carbon (a partir de 1º/12)	US$ 4,00	US$ 20,00	US$ 0,20	Não
Gemini 4 Argon (até 30/11)	US$ 2,00	US$ 10,00	US$ 0,10	Não
Gemini 4 Argon (a partir de 1º/12)	US$ 4,00	US$ 20,00	US$ 0,20	Não
Gemini 3.8 Flash (até 31/12)	US$ 0,75	US$ 3,75	US$ 0,075	Sim
Gemini 3.8 Flash (a partir de 1º/1/2027)	US$ 1,50	US$ 7,50	US$ 0,15	Sim

Aplicando as contagens de tokens do loop de agente do Exemplo 2 a cada preço, você obtém US$ 2,47 no Hydrogen, US$ 3,29 no Carbon ou Argon este mês e US$ 6,58 a partir de 1º de dezembro, e US$ 1,27 no Gemini 3.8 Flash até 31 de dezembro. Quando o preço do Flash sobe em 1º de janeiro de 2027, os mesmos tokens custam US$ 2,54 no Flash, um pouco mais que no Hydrogen, porque a tarifa de cache do Flash dobra para US$ 0,15. Para os detalhes sobre a mudança de preços dos modelos frontier, consulte nossos guias de preços do Gemini 4 Carbon e preços do Gemini 4 Argon.

Mesmos tokens não é a comparação real, porém, porque cada modelo gasta uma quantidade diferente de tokens por tarefa. As páginas do Intelligence Index da Artificial Analysis oferecem uma visão:

Modelo (nível de thinking)	Pontuação no índice	Tokens gerados	Custo por tarefa do índice
Gemini 4 Hydrogen (high)	51	110M	US$ 1,87
Gemini 4 Hydrogen (xhigh)	54	304M	US$ 3,16
Gemini 4 Argon (high)	50	113M	US$ 4,97
Gemini 4 Carbon (high)	60	205M	US$ 5,48
Gemini 3.8 Flash (high)	31	126M	não comparado aqui

Nesse benchmark, o Hydrogen em seu nível padrão igualou a pontuação do Argon a cerca de 38% do custo por tarefa do Argon, enquanto o Carbon obteve a pontuação mais alta. Trate isso como a visão de um único benchmark. O Google também afirma que o Hydrogen conclui tarefas 2,5x mais rápido que o Gemini 3.8 Flash na configuração high.

A divisão prática: Hydrogen para codificação do dia a dia e agentes, Carbon para arquitetura complexa, depuração e revisões de segurança. No Antigravity, a opção Orchestrator alterna entre Carbon e Hydrogen dentro de uma mesma execução. Nossa comparação entre Gemini 4 Carbon e Argon cobre o lado dos modelos frontier.

Como reduzir sua fatura do Gemini 4 Hydrogen?

Use Batch ou Flex para trabalhos que podem esperar. Ambos custam metade do preço.
Escolha o menor nível de thinking que passe nos seus evals. O medium usou cerca de metade dos tokens do high.
Reserve o xhigh para os turnos difíceis.
Mantenha um prefixo de prompt estável para que o cache implícito cobre a entrada repetida a US$ 0,075 por 1M, um desconto de 95%.
Faça protótipos no nível Free.

Meça seu custo real do Gemini 4 Hydrogen com a Apidog CLI

Sua fatura vem dos seus próprios prompts. A forma mais rápida de obter números reais é deixar seu agente de código (Claude Code, Codex, Cursor) executar seus prompts em todos os níveis de thinking por meio da Apidog CLI e registrar o objeto usage de cada execução.

Configure uma vez:

npm install -g apidog-cli@latest
apidog login --with-token <YOUR_TOKEN>
npx -y skills add https://apidog.com   # pick your agent when prompted

Coloque de 5 a 10 dos seus prompts reais em levels.csv, uma linha por prompt e nível de thinking, com as colunas prompt e thinking_level (low, medium, high, xhigh). Depois, dê ao seu agente um único prompt:

In Apidog project <projectId>, create a test case for
POST https://generativelanguage.googleapis.com/v1beta/interactions
with the x-goog-api-key header read from GEMINI_API_KEY in environment
<envId>. Send model "gemini-4-hydrogen", input {{prompt}} and
generation_config.thinking_level {{thinking_level}}. Assert status 200,
status "completed", non-empty output, and a usage object that includes
total_input_tokens and total_output_tokens. In a post-processor, read
total_input_tokens, total_cached_tokens, total_thought_tokens and
total_output_tokens, compute cost at $1.50 input, $0.075 cached and
$7.50 output per 1M, and log it. Run every row of levels.csv and give me
a table of tokens and cost per prompt and thinking level.

O agente verifica o formato do payload antes de escrever qualquer coisa e, em seguida, executa todas as linhas:

apidog cli-schema get test-case-create
apidog cli-schema validate test-case-create --file case.json
apidog test-case create --project <projectId> --file case.json
apidog run --test-case <caseId> --project <projectId> -e <envId> \
  -d levels.csv -r cli,json --out-file hydrogen-cost-{GENERATE_TIME}

O relatório JSON mostra quanto cada nível de thinking custa na sua carga de trabalho. Adicione -r junit e o mesmo comando roda em CI, onde uma asserção de orçamento de tokens pode falhar o build. O guia de CI/CD da Apidog CLI mostra o pipeline, e o Apidog CLI no Claude Code cobre a configuração do agente. O plano Free da Apidog cobre até 4 usuários.

Um atalho: diga ao seu agente "Leia https://apidog.com/apidog-cli-installation-guide.md e configure a Apidog CLI."

FAQ

O Gemini 4 Hydrogen é gratuito? Na API, sim, dentro dos limites de taxa do nível Free: o Google lista entrada e saída Standard como "Gratuito" no nível Free. Batch, Flex e grounding com Search exigem uma chave paga. Consulte nosso guia do Gemini 4 Hydrogen gratuito.

O preço do Gemini 4 Hydrogen vai subir como o do Carbon? A página de preços do Google lista uma única tarifa de US$ 1,50/US$ 7,50 para o Hydrogen, sem período introdutório ou data de término. Carbon e Argon têm preços introdutórios com data marcada; o Hydrogen não.

Os tokens de thinking são cobrados no Gemini 4 Hydrogen? Sim, à tarifa de saída de US$ 7,50 por 1M no Standard. O objeto usage da resposta os reporta separadamente como total_thought_tokens.

O Gemini 4 Hydrogen é mais barato que o Gemini 3.8 Flash? Não neste ano: o Flash custa US$ 0,75/US$ 3,75 até 31 de dezembro de 2026. A partir de 1º de janeiro de 2027, o Flash sobe para US$ 1,50/US$ 7,50, a mesma tarifa por token do Hydrogen, e o Hydrogen marcou 51 contra 31 do Flash no índice da Artificial Analysis.

Como usar o Gemini 4 Hydrogen por $0 hoje

Lucas — Fri, 13 Nov 2026 07:56:37 +0000

Sim, o Gemini 4 Hydrogen é gratuito. O Google colocou o gemini-4-hydrogen no nível gratuito da API do Gemini e no Google AI Studio em 12 de novembro de 2026, então você pode chamá-lo com uma chave de API gratuita a $0, dentro dos limites de taxa. Usuários gratuitos do app Gemini só o acessam por meio da seleção automática de modelo, e o Google Search o usa para todos.

Experimente o Apidog hoje

O que não é gratuito: o Hydrogen no Google Antigravity, o novo Orchestrator, o Gemini no Sheets e o nível pago da API. Abaixo: cada caminho gratuito, suas pegadinhas e como aproveitar ao máximo a cota.

O Gemini 4 Hydrogen é gratuito?

O Gemini 4 Hydrogen é gratuito no nível gratuito da API do Gemini e no Google AI Studio. A página de preços do Google lista entrada, saída e cacheamento de contexto como "Gratuito" no nível gratuito, com limites de taxa. O nível pago custa $1,50 por 1 milhão de tokens de entrada e $7,50 por 1 milhão de tokens de saída, valores fixos em toda a janela de contexto de 1 milhão de tokens.

Isso torna o Hydrogen o primeiro modelo Gemini 4 com nível gratuito: a entrada do Argon diz que ele "não está disponível no nível gratuito", e nosso guia sobre o Gemini 4 Carbon gratuito cobre o Carbon. Para uma visão completa do modelo, comece com o que é o Gemini 4 Hydrogen.

Aqui está o que o Google publicou:

Item	Nível gratuito	Nível pago	Fonte
ID do modelo	`gemini-4-hydrogen`	`gemini-4-hydrogen`	Novidades do AI Studio
Preço de entrada	Gratuito	$1,50 / 1M tokens	Página de preços
Preço de saída (incl. pensamento)	Gratuito	$7,50 / 1M tokens	Página de preços
Entrada em cache (apenas implícito)	Gratuito	$0,075 / 1M tokens	Página de preços
Grounding com o Google Search	Indisponível	5.000 solicitações gratuitas/mês, depois $14 por 1.000	Página de preços
Conteúdo usado para melhorar os produtos	Sim	Não	Página de preços
Janela de contexto	1.048.576 tokens, compartilhados entre entrada, pensamento e saída	Igual	Página do modelo
Níveis de pensamento	`low`, `medium`, `high` (padrão), `xhigh`	Igual	Novidades do AI Studio

Todos os caminhos gratuitos para o Gemini 4 Hydrogen

Três caminhos custam $0 hoje. Cada um oferece uma fatia diferente do Hydrogen:

Caminho	Custo	Como você acessa o Hydrogen	Escolhe o modelo você mesmo?	Precisa de cartão?
Nível gratuito da API do Gemini	$0	Chamar `gemini-4-hydrogen` com uma chave gratuita	Sim	Não mencionado; o Google exige um projeto ativo
Google AI Studio	$0	Conversar com `model=gemini-4-hydrogen`	Sim	Igual ao anterior
App Gemini, sem plano Google AI	$0	A seleção automática de modelo pode rotear um prompt para o Hydrogen	Não	Não
Google Search	$0	Alimenta as respostas de IA do Search para todos os usuários	Não	Não

Caminho 1: O nível gratuito da API do Gemini

Este é o caminho para desenvolvedores. Crie uma chave no Google AI Studio e envie solicitações para o gemini-4-hydrogen. A página de limites de taxa do Google lista a qualificação para o nível gratuito como "Projeto ativo ou teste gratuito", com verificação para alguns projetos. Não há menção a método de pagamento. O faturamento começa no Tier 1.

Aqui está uma primeira chamada pelo endpoint generateContent. O Hydrogen usa high como padrão de pensamento, então defina low ou medium quando quiser menos tokens por solicitação:

curl -s "https://generativelanguage.googleapis.com/v1beta/models/gemini-4-hydrogen:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{"parts": [{"text": "Write three test cases for a token-bucket rate limiter."}]}],
    "generationConfig": {"thinkingConfig": {"thinkingLevel": "medium"}}
  }'

Os SDKs usam a API Interactions em vez disso; nosso guia da API do Gemini 4 Hydrogen cobre ambos, além de decodificação longa e chamadas de ferramentas.

Caminho 2: Google AI Studio

O AI Studio é o caminho sem código: converse com o Hydrogen, teste cada nível de pensamento e copie o código. A página de preços diz que "o uso do Google AI Studio é gratuito em todas as regiões disponíveis". O AI Studio também é onde você vê seus próprios limites de taxa, porque o Google não publica uma tabela fixa para o nível gratuito do Hydrogen.

Caminho 3: O app Gemini, plano gratuito

Usuários gratuitos podem acessar o Hydrogen no app Gemini, mas não podem escolhê-lo. A página de ajuda dos apps Gemini lista "Auto ou Flash-Lite" para contas sem plano Google AI: "Prompts que exigem mais raciocínio podem usar o Hydrogen. Se a seleção automática de modelo estiver desativada, todas as respostas usarão o Flash-Lite." Mantenha o modo automático ativado e espere o Hydrogen apenas em prompts mais difíceis.

Caminho 4: Google Search

A publicação sobre o Search do Google diz que o Hydrogen "já está disponível globalmente no Google Search para todos os usuários". Não é necessário plano nem chave, mas você não pode controlar o modelo nem construir sobre ele.

O que não é gratuito

A publicação de lançamento do Google e o blog do Antigravity colocam estes recursos atrás de um plano pago:

Google Antigravity. O Hydrogen "está sendo distribuído para assinantes pagos do Google AI Pro e Ultra". Não há caminho gratuito para o Hydrogen no Antigravity.
Orchestrator. O Ultra tem Orchestrator (Carbon) e Orchestrator (Argon); o Pro pago tem Orchestrator (Argon). Nosso guia do Gemini 4 Hydrogen Orchestrator explica como ele distribui o trabalho entre Carbon e Hydrogen.
Gemini no Google Sheets. Disponível a partir do Google AI Pro e Ultra.
Grounding de pesquisa na API. O Grounding com o Google Search aparece como "Indisponível" no nível gratuito.
Tratamento de dados privados. No nível gratuito, o conteúdo é "usado para melhorar nossos produtos". Apenas o nível pago diz que não.
Batch API. O Google a lista, com 50% de desconto, no plano pago.

Sites de terceiros com "API gratuita do Hydrogen" não são caminhos do Google; mantenha suas chaves longe deles.

Limites do nível gratuito do Gemini 4 Hydrogen

O Google não publicou números fixos para o nível gratuito do Hydrogen; os limites "podem ser consultados no Google AI Studio". Eis o que o Google confirma:

Os limites são por projeto, não por chave de API. Chaves extras no mesmo projeto não aumentam a cota.
As solicitações por dia são redefinidas à meia-noite, horário do Pacífico.
Os limites cobrem solicitações por minuto, tokens por minuto e solicitações por dia. Ultrapassar qualquer um deles gera HTTP 429.
A transição do gratuito para o Tier 1 normalmente entra em vigor imediatamente assim que você vincula uma conta de faturamento.

Como aproveitar ao máximo a cota gratuita

Os tokens de pensamento também contam. Cinco hábitos fazem o nível gratuito durar mais:

Comece com o pensamento medium. high é o padrão; low usa a menor quantidade de tokens. O Google sugere escolher o nível mais baixo que atenda ao seu padrão de qualidade.
Reserve xhigh para problemas difíceis. O Google avisa que ele aumenta a latência e o uso de tokens e "pode causar pensamento excessivo em prompts mais simples".
Reaproveite prompts longos. O cacheamento implícito funciona em prompts de pelo menos 4.096 tokens. O cacheamento explícito não é compatível com o Hydrogen.
Roteie tarefas fáceis para outro lugar. O Google mantém o Gemini 3.5 Flash-Lite para classificação e roteamento de alto volume.
Espere ao receber 429 com atraso exponencial, não um loop apertado.

Um wrapper mínimo de nova tentativa fica assim:

for attempt in 1 2 3 4 5; do
  code=$(curl -s -o out.json -w "%{http_code}" \
    "https://generativelanguage.googleapis.com/v1beta/models/gemini-4-hydrogen:generateContent" \
    -H "x-goog-api-key: $GEMINI_API_KEY" -H "Content-Type: application/json" \
    -d '{"contents":[{"parts":[{"text":"Summarize this changelog."}]}],
         "generationConfig":{"thinkingConfig":{"thinkingLevel":"low"}}}')
  [ "$code" != "429" ] && break
  sleep $((2 ** attempt))   # 2, 4, 8, 16, 32 seconds
done
echo "HTTP $code"

HTTP 429 Too Many Requests explica o código de status. Quando o nível gratuito não for mais suficiente, nosso guia de preços do Gemini 4 Hydrogen faz as contas por chamada, e você pode compará-lo com os preços do Gemini 4 Carbon e os preços do Gemini 4 Argon.

Migrando do Gemini 3.8 Flash gratuitamente

Se você usa o caminho gratuito do Gemini 3.8 Flash, o Google chama o Hydrogen de "atualização recomendada", e ambos estão no nível gratuito. Mude a string do modelo, remova o pensamento minimal (o Hydrogen o rejeita), remova temperature, top_p, top_k e cached_content, e aumente limites baixos de max_output_tokens para 65.536. O Google relata que o Hydrogen é 2,5x mais rápido que o 3.8 Flash no pensamento alto; teste seus próprios prompts antes de migrar.

Deixe seu agente de codificação testá-lo com o Apidog CLI

Não gaste cota gratuita com novas tentativas escritas à mão. Deixe seu agente de codificação configurar a solicitação do Hydrogen uma vez, verificar as asserções na resposta e executá-la sob demanda. O Apidog CLI dá aos comandos para Claude Code, Codex ou Cursor, e o plano gratuito do Apidog cobre até 4 usuários.

npm install -g apidog-cli@latest
apidog login --with-token <YOUR_TOKEN>
npx -y skills add https://apidog.com   # pick your agent when prompted

Depois, dê ao seu agente um único prompt:

In Apidog project <id>, create an environment "gemini-free" with base URL
https://generativelanguage.googleapis.com/v1beta. Add a test case for
POST /models/gemini-4-hydrogen:generateContent with the key from
{{GEMINI_API_KEY}} and thinkingLevel "medium". Assert HTTP 200, a non-empty
candidates array and a usageMetadata object. Run it with a 2-second delay
between requests and summarize any failures, including 429s.

O agente cria o ambiente, lê o esquema, valida seu payload, escreve o caso de teste e o executa:

apidog environment create gemini-free --project <id> \
  --base-url https://generativelanguage.googleapis.com/v1beta
apidog cli-schema get test-case-create
apidog cli-schema validate test-case-create --file case.json
apidog test-case create --project <id> --file case.json
apidog run --test-case <caseId> --project <id> -e <envId> \
  --env-var "GEMINI_API_KEY=$GEMINI_API_KEY" --delay-request 2000 -r cli,json

O --delay-request (em milissegundos) espaça as solicitações dentro do seu limite por minuto, e o --env-var passa a chave do seu shell em vez de armazená-la no projeto. O guia Apidog CLI no Claude Code cobre a configuração do agente, e o Apidog CLI em CI/CD executa o mesmo caso a cada push.

FAQ

O Gemini 4 Hydrogen é gratuito? Sim, no nível gratuito da API do Gemini e no Google AI Studio, dentro dos limites de taxa. Usuários gratuitos do app Gemini só o acessam por meio da seleção automática de modelo, e o Google Search o usa para todos os usuários.

Preciso de cartão de crédito para o nível gratuito do Gemini 4 Hydrogen? A página de limites de taxa do Google lista um projeto ativo ou teste gratuito como requisito do nível gratuito e não menciona método de pagamento. O faturamento começa no Tier 1.

Quais são os limites de taxa do nível gratuito do Gemini 4 Hydrogen? O Google não publica uma tabela fixa. Você vê os limites do seu projeto no Google AI Studio. Os limites se aplicam por projeto, e as cotas diárias são redefinidas à meia-noite, horário do Pacífico.

Posso escolher o Gemini 4 Hydrogen no app Gemini gratuito? Não. Sem plano Google AI, você recebe Auto ou Flash-Lite. O Auto pode rotear prompts mais difíceis para o Hydrogen; com o automático desativado, toda resposta usa o Flash-Lite.

O Gemini 4 Hydrogen é gratuito no Google Antigravity? Não. O Google está distribuindo-o para assinantes pagos do Google AI Pro e Ultra, e o Orchestrator também é limitado a esses planos.

Comece grátis, faça upgrade mudando uma string

O Gemini 4 Hydrogen é o primeiro modelo Gemini 4 sobre o qual você pode construir por $0: uma chave gratuita do AI Studio, gemini-4-hydrogen como modelo, pensamento medium e backoff em 429. Para o lado pago, veja Gemini 4 Carbon vs Argon e o que é o Gemini 4 Carbon. Baixe o Apidog e deixe seu agente manter os testes do Hydrogen verdes conforme você escala.

O que é o Gemini 4 Hydrogen? O modelo rápido do Google para tarefas de agentes de IA

Lucas — Fri, 13 Nov 2026 07:56:03 +0000

Gemini 4 Hydrogen: o modelo rápido e barato do Google para programação e agentes

O Gemini 4 Hydrogen é o modelo Gemini 4 rápido e de custo mais baixo da Google, lançado em 12 de novembro de 2026 e projetado para programação do dia a dia e trabalho com agentes. Custa US$ 1,50 por milhão de tokens de entrada e US$ 7,50 por milhão de tokens de saída em um contexto de 1 milhão de tokens, oferece quatro níveis de raciocínio (low, medium, high, xhigh) e está disponível no nível gratuito da API Gemini.

Experimente o Apidog hoje

Se você usa o Gemini 3.8 Flash, o Hydrogen é a atualização recomendada pela Google. Se você paga pelo Carbon ou pelo Argon em etapas rotineiras, o Hydrogen foi feito para assumir essas tarefas. Veja o que foi lançado, como ele se encaixa no ecossistema e o que ainda permanece desconhecido.

O que é o Gemini 4 Hydrogen?

O Gemini 4 Hydrogen (gemini-4-hydrogen) é o nível de velocidade da família Gemini 4 da Google. A Google o chama de "motor do dia a dia para fluxos de trabalho agentivos": um modelo que escreve código, chama ferramentas, executa testes e lê documentos rapidamente, seja de forma independente ou como motor de execução sob um modelo de fronteira como o Gemini 4 Carbon.

Os fatos principais, extraídos do post de lançamento da Google e do guia "Novidades" do AI Studio:

Especificação	Gemini 4 Hydrogen
ID do modelo	`gemini-4-hydrogen`
Lançamento	12 de novembro de 2026
Preço pago	US$ 1,50 / 1M de entrada, US$ 7,50 / 1M de saída (preço fixo em todo o contexto)
Entrada em cache	US$ 0,075 / 1M de tokens com cache implícito
Janela de contexto	1.048.576 tokens, compartilhados entre entrada, raciocínio e saída
Saída por requisição	65.536 tokens de forma síncrona; até 1M com execução em segundo plano
Níveis de raciocínio	`low`, `medium`, `high` (padrão), `xhigh`
Entradas	Texto, imagens, PDFs, planilhas, gráficos, áudio, vídeo
Nível gratuito	Sim, com limites de taxa, no AI Studio e na API Gemini
APIs	`generateContent` e a API Interactions

Os tokens de saída incluem os tokens de raciocínio, portanto uma requisição em xhigh custa mais do que a mesma requisição em low, mesmo quando a resposta visível tem o mesmo tamanho.

Hydrogen vs Carbon vs Argon: onde ele se encaixa

Os três modelos Gemini 4 compartilham o mesmo contexto unificado de 1M, o design de decodificação longa e as ferramentas integradas. Eles se diferenciam em quanto raciocinam por turno e quanto custam.

	Hydrogen	Argon	Carbon
Função	Execução rápida, programação do dia a dia	A maioria das tarefas de longo prazo, com menos tokens que o Carbon	Modelo de fronteira mais poderoso
Raciocínio padrão	`high`	`medium`	`medium`
Raciocínio máximo	`xhigh`	`high`	`high`
Limite sem streaming	65.536 tokens	32.768 tokens (REST)	32.768 tokens (REST)
Recomendação da Google	Caminho de atualização a partir do 3.8 Flash	Tarefas longas avançadas	Arquitetura complexa, segurança, ciência

A própria orientação da Google é combiná-los: deixe o Carbon planejar interfaces ou desvendar um bug difícil e, em seguida, entregue ao Hydrogen as edições de código, o trabalho paralelo de subagentes e a execução de testes. A troca de modelos dentro de uma mesma conversa funciona por meio do previous_interaction_id na API Interactions, sem alterações no esquema de requisições.

Para uma comparação mais detalhada entre os dois modelos de fronteira, leia Gemini 4 Carbon vs Argon. Para os custos, consulte as análises de preços do Carbon e preços do Argon.

Os quatro níveis de raciocínio

O nível de raciocínio do Hydrogen é seu principal controle sobre velocidade, qualidade e custo. Ele é definido pelo campo thinking_level, e a Google recomenda começar com o padrão e mudar apenas quando seus testes de avaliação indicarem.

low: menos tokens, menor latência. Chat rápido e processamento de alto volume.
medium: programação interativa, prototipagem de UI em tempo real e chamadas de ferramentas sensíveis à latência.
high (padrão): programação complexa, execução agentiva, chamadas de ferramentas e trabalho com documentos multimodais.
xhigh: novidade do Hydrogen. Problemas difíceis de múltiplas etapas em que o high não é suficiente.

A Google alerta que o xhigh pode raciocinar demais em prompts simples, adicionando latência e tokens sem produzir uma resposta melhor. A recomendação: execute sua suíte de avaliações nos quatro níveis com um max_output_tokens generoso e escolha o nível mais baixo que atenda ao seu padrão de qualidade. Se você está migrando do 3.8 Flash, saiba que o Hydrogen rejeita minimal com um erro e usa high como padrão, em vez de medium. O guia de preços do Hydrogen detalha o custo de cada nível.

Benchmarks do Gemini 4 Hydrogen

Todos os números abaixo são da Google, publicados no lançamento. A replicação independente era escassa um dia após o lançamento, portanto trate-os como alegações do fornecedor.

Contra o Argon e suas próprias configurações

Índice de Inteligência da Artificial Analysis: 51 em high, à frente dos 50 do Argon, e 54 em xhigh.

Contra o Gemini 3.8 Flash

2,5x mais rápido no padrão high.
Terminal-Bench 4.1: 57% vs 18,2%.
Mais de 5x menos alegações fabricadas.
Parceiros de lançamento relatam execuções 2x a 2,8x mais rápidas e 12% a 23% menos tokens em workloads de grafos, SQL e com grande volume de dados.

Trabalho agentivo e por domínio

HLE-Diamond: 58,8%, o que segundo a Google lidera sua categoria.
Vals Tax Agent Bench: 1º lugar com 52,3%.
Vals Legal Research Bench: empate em 1º lugar com 55,8%.
Agent Arena (arena.ai): 5º lugar.
Multimodal Knowledge Agent (MKA): 53,4%.
Agents' Last Exam v1.1: 71,6%.

Segurança, segundo a Google

Até 81% menos excesso de intervenção e até 79% menos subatendimento em tarefas agentivas.
12x menos ações desalinhadas e atalhos em tarefas nas avaliações de uso de ferramentas e programação.
96,7% na avaliação interna de honestidade de agentes da Google.
Mais de 2,3x mais resistente à injeção indireta de prompts no benchmark Gray Swan IPI.

O padrão geral importa mais do que qualquer pontuação isolada: o Hydrogen praticamente iguala o Argon em inteligência geral e representa um salto grande em relação ao 3.8 Flash em programação agentiva. Teste-o no seu próprio workload antes de confiar nele. O model card traz as notas completas de avaliação da Google.

Onde você já pode usar o Gemini 4 Hydrogen

A Google lançou o Hydrogen em produtos de desenvolvimento, negócios e consumo no dia do lançamento:

API Gemini, Google AI Studio e Android Studio: todos os níveis, gratuitos e pagos. O nível gratuito tem limites de taxa; o guia gratuito do Hydrogen cobre o que você obtém sem cadastrar cartão.
Gemini para empresas: via API, no seletor de modelos, no Antigravity e no Gemini no Google Sheets para planos empresariais elegíveis.
App Gemini: no seletor de modelos. Usuários gratuitos têm acesso ao Hydrogen apenas por meio da seleção automática de modelo, quando o Gemini decide que ele é adequado ao prompt.
Google Search: gerando respostas para todos os usuários.
Google Sheets: começando com assinantes do Google AI Pro e Ultra.
Google Antigravity: para assinantes pagos do Google AI Pro e Ultra.

O Hydrogen também é agora o modelo padrão por trás do agente Antigravity no Gemini Managed Agents, então qualquer pessoa que chamar esse agente pela API já está usando o Hydrogen, a menos que configure outro modelo.

Orchestrator: Hydrogen e Carbon em uma mesma sessão

O Orchestrator é uma nova opção de modelo no Google Antigravity que alterna entre Carbon e Hydrogen dentro de uma mesma tarefa, em ambas as direções. O Carbon explora e planeja, o Hydrogen escreve edições, atualiza pacotes e executa testes e, quando o Hydrogen encontra obstáculos, devolve o controle ao Carbon para corrigir o plano. Ele substitui o roteador estático que estima a dificuldade uma única vez com base no seu primeiro prompt.

No Terminal-Bench, a Google afirma que o Orchestrator alcançou taxas de sucesso próximas às do Carbon usando 24% menos cota e concluindo em média 19% mais rápido. Vale notar que os dois posts de lançamento da Google citam versões diferentes do benchmark para esse resultado (4.0 no post principal, 4.1 no post do Antigravity).

A disponibilidade é segmentada por plano. Assinantes Ultra têm acesso ao Orchestrator (Carbon) e ao Orchestrator (Argon); assinantes pagos do plano Pro têm acesso ao Orchestrator (Argon). Se preferir definir os papéis você mesmo, o SDK do Antigravity permite atribuir agentes Hydrogen e Carbon explicitamente. O guia do Gemini 4 Hydrogen Orchestrator vai mais a fundo.

Limitações e questões em aberto

Um dia após o lançamento, planeje levando em conta o seguinte:

Os benchmarks são autorreportados. Todos os números acima vêm da Google ou de seus parceiros de lançamento.
Sem cache explícito. cachedContents e caches.create não são suportados; aplica-se apenas o cache implícito em prompts de 4.096 tokens ou mais.
Parâmetros de amostragem são ignorados. temperature, top_p e top_k não têm efeito, então não é possível ajustar a aleatoriedade dessa forma.
Os limites do nível gratuito ficam em uma página separada. A Google direciona para sua página de limites de taxa em vez de listar os números do Hydrogen no guia de lançamento.
O Orchestrator é exclusivo do Antigravity. Não há Orchestrator no nível da API; no seu próprio código, você faz o roteamento entre modelos por conta própria.

Teste o Gemini 4 Hydrogen com a Apidog CLI e seu agente de programação

Para decidir se o Hydrogen pode substituir o 3.8 Flash, execute a mesma requisição em ambos e compare os resultados. Deixe seu agente de programação fazer isso, para que a troca se torne um resultado de teste, não um palpite. Esta requisição segue o formato generateContent documentado pela Google; não a executamos em produção para este post:

MODEL="${GEMINI_MODEL:-gemini-4-hydrogen}"

curl -s "https://generativelanguage.googleapis.com/v1beta/models/${MODEL}:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"contents": [{"parts": [{"text": "List three checks a CI job should run before a release."}]}]}'

A Apidog CLI oferece ao Claude Code, Codex, Cursor ou OpenCode uma forma de criar e executar testes de API pela linha de comando. Configure uma vez:

npm install -g apidog-cli@latest
apidog login --with-token <YOUR_TOKEN>
npx -y skills add https://apidog.com   # pick your agent when prompted

Depois, dê ao seu agente um único prompt:

In Apidog project <id>, create an environment for the Gemini API with a MODEL
variable set to gemini-4-hydrogen and a GEMINI_API_KEY variable. Add a test case
for POST /v1beta/models/{MODEL}:generateContent that asserts HTTP 200, a non-empty
candidates array, and that usageMetadata is present. Run it for gemini-4-hydrogen
and gemini-3.8-flash and compare response time and token counts.

O agente cria o ambiente, valida o payload do caso de teste contra seu esquema e o executa uma vez por modelo:

apidog environment create gemini-api --project <id> --base-url https://generativelanguage.googleapis.com
apidog cli-schema get test-case-create
apidog cli-schema validate test-case-create --file case.json
apidog test-case create --project <id> --file case.json
apidog run --test-case <caseId> --project <id> -e <envId> --env-var "MODEL=gemini-4-hydrogen" -r cli,json
apidog run --test-case <caseId> --project <id> -e <envId> --env-var "MODEL=gemini-3.8-flash" -r cli,json

Adicione o mesmo apidog run ... -r junit ao seu CI com o guia de CI/CD da Apidog CLI, ou comece pelo Apidog CLI no Claude Code. Para exemplos completos de requisições, veja o guia da API do Gemini 4 Hydrogen. O plano gratuito da Apidog cobre até 4 usuários.

Perguntas frequentes

O Gemini 4 Hydrogen é gratuito? Sim, dentro de certos limites. A Google lista o Hydrogen no nível gratuito da API Gemini e no Google AI Studio, com limites de taxa. O uso pago custa US$ 1,50 por milhão de tokens de entrada e US$ 7,50 por milhão de tokens de saída.

Qual é o ID do modelo Gemini 4 Hydrogen? gemini-4-hydrogen. Funciona tanto com generateContent quanto com a API Interactions.

O Gemini 4 Hydrogen é melhor que o Gemini 4 Argon? Pelos números da Google, o Hydrogen pontua 51 no Índice de Inteligência da Artificial Analysis em high, contra 50 do Argon, e 54 em xhigh. O Argon ainda é posicionado para a maioria das tarefas avançadas de longo prazo, então teste ambos no seu próprio workload.

O que é o nível de raciocínio xhigh? É um quarto nível de raciocínio, novidade do Hydrogen, acima do padrão high. Gasta o máximo de tokens para o raciocínio mais profundo. A Google recomenda usá-lo apenas em problemas difíceis de múltiplas etapas em que o high não é suficiente.

O Gemini 4 Hydrogen substitui o Gemini 3.8 Flash? A Google o apresenta como a atualização recomendada a partir do 3.8 Flash. Troque o ID do modelo, aumente quaisquer limites baixos de max_output_tokens, remova o cache explícito e os parâmetros de amostragem e teste novamente seu nível de raciocínio.

Posso usar o Orchestrator pela API Gemini? Não. O Orchestrator é uma opção de modelo dentro do Google Antigravity para assinantes pagos do AI Pro e Ultra. Na API, você mesmo faz o roteamento entre Carbon e Hydrogen, por exemplo com previous_interaction_id entre turnos.

Como usar a API do Gemini 4 Hydrogen?

Lucas — Fri, 13 Nov 2026 07:54:03 +0000

Como usar a API do Gemini 4 Hydrogen: chave, primeira requisição, pensamento, PDF, function calling, streaming e erros

A API do Gemini 4 Hydrogen usa o ID de modelo gemini-4-hydrogen. Você a chama com um POST para https://generativelanguage.googleapis.com/v1beta/interactions, com sua chave no cabeçalho x-goog-api-key e model mais input no corpo JSON. Ela está disponível no nível gratuito e no nível pago (US$ 1,50 de entrada, US$ 7,50 de saída por 1M de tokens) e usa por padrão o nível de pensamento high.

Experimente o Apidog hoje

Este guia percorre todo o caminho: chave, primeira requisição, nível de pensamento, um PDF, function calling, streaming e tratamento de erros. Todos os nomes de campos vêm da documentação do Google.

O que você precisa antes da sua primeira chamada à API do Gemini 4 Hydrogen?

Você precisa de uma chave da API Gemini, do ID de modelo gemini-4-hydrogen e do endpoint Interactions. O Google lançou o Hydrogen em 12 de novembro de 2026, como o modelo rápido da linha Gemini 4 ao lado de Carbon e Argon (o que é o Gemini 4 Hydrogen).

Item	Valor
ID do modelo	`gemini-4-hydrogen`
Endpoint	`POST /v1beta/interactions` em `generativelanguage.googleapis.com`
Cabeçalho de autenticação	`x-goog-api-key: $GEMINI_API_KEY`
APIs	Interactions API e `generateContent`
Níveis de pensamento	`low`, `medium`, `high` (padrão), `xhigh`
Janela de contexto	1.048.576 tokens, compartilhados entre entrada, pensamento e saída
Saída por ciclo síncrono	65.536 tokens, com ou sem streaming
Nível gratuito	Sim, com limites de taxa
Preço pago	US$ 1,50 / 1M de entrada, US$ 7,50 / 1M de saída (pensamento incluído)
Entrada em cache	US$ 0,075 / 1M via cache implícito

A documentação do Google considera o generateContent legado, por isso estes exemplos usam a API Interactions.

Como obter uma chave da API Gemini para o Hydrogen?

O Hydrogen está no nível gratuito, então você pode começar sem configurar faturamento:

Abra a página de chaves de API no Google AI Studio.
Clique em Create API key. Novas chaves criadas no AI Studio são chaves de autorização, vinculadas a uma conta de serviço.
Exporte-a: export GEMINI_API_KEY="YOUR_API_KEY". Os SDKs leem GEMINI_API_KEY ou GOOGLE_API_KEY; se ambas estiverem definidas, GOOGLE_API_KEY tem precedência.
Um projeto do Cloud criado fora do AI Studio pode precisar de verificação do projeto antes que o nível gratuito funcione.

O Google publica os números do nível gratuito em sua página de limites de taxa, não no guia de lançamento. Nosso guia do Gemini 4 Hydrogen gratuito cobre o que você recebe por US$ 0.

Como enviar sua primeira requisição à API do Gemini 4 Hydrogen?

Envie model e input para o endpoint Interactions. Mantenha o modelo em uma variável para que trocar de modelo seja uma mudança de uma linha.

export GEMINI_MODEL="gemini-4-hydrogen"

curl "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -X POST \
  -d '{
    "model": "'"$GEMINI_MODEL"'",
    "input": "Write a Python function that retries an HTTP call with exponential backoff."
  }'

A mesma chamada com o SDK Python (pip install -U google-genai):

import os
from google import genai

client = genai.Client()  # reads GEMINI_API_KEY

interaction = client.interactions.create(
    model=os.environ.get("GEMINI_MODEL", "gemini-4-hydrogen"),
    input="Write a Python function that retries an HTTP call with exponential backoff.",
)

print(interaction.output_text)
print(interaction.usage)

A resposta traz um id, um status e um array steps. O texto fica nas etapas model_output, o raciocínio nas etapas thought, e o output_text do SDK junta o texto para você. O objeto usage contém total_input_tokens, total_thought_tokens, total_output_tokens e total_tokens.

Estes snippets seguem o quickstart do Google. Não os executamos para este post (não havia chave do Gemini na nossa máquina de testes), então confira o formato com a sua primeira resposta.

Como definir o nível de pensamento do Gemini 4 Hydrogen?

Defina thinking_level dentro de generation_config. O Hydrogen usa high por padrão, adiciona um novo nível xhigh e rejeita minimal com um erro.

`thinking_level`	Uso de tokens	Uso recomendado pelo Google
`low`	Menos tokens, menor latência	Chat rápido, processamento de alto volume
`medium`	Menos tokens, mais rápido	Codificação interativa, prototipagem de UI ao vivo, chamadas rápidas de ferramentas
`high` (padrão)	Equilibrado	Codificação complexa, execução agêntica, trabalho com documentos multimodais
`xhigh`	Mais tokens, raciocínio mais profundo	Problemas difíceis de múltiplas etapas em que `high` não é suficiente

curl "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -X POST \
  -d '{
    "model": "gemini-4-hydrogen",
    "input": "Audit this payment retry queue for race conditions.",
    "generation_config": {
      "thinking_level": "medium",
      "max_output_tokens": 65536
    }
  }'

Duas regras importam. max_output_tokens limita pensamento e saída juntos, então um limite antigo baixo (digamos, 8.192) pode cortar as respostas; o Google recomenda aumentá-lo para 65.536 e, em vez disso, baixar o nível de pensamento. E os tokens de pensamento são cobrados à taxa de saída de US$ 7,50, então xhigh custa mais mesmo quando a resposta visível tem o mesmo tamanho. A análise de preços do Gemini 4 Hydrogen faz as contas por nível.

O Google também informa que o servidor ignora temperature, top_p e top_k no Hydrogen, então remova-os das suas requisições.

Como enviar um PDF para o Gemini 4 Hydrogen?

Adicione um item document ao array input, ao lado de um item text com sua instrução. Para arquivos pequenos, envie o PDF inline em base64:

PDF_PATH="invoice.pdf"
B64=$(base64 < "$PDF_PATH" | tr -d '\n')

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "gemini-4-hydrogen",
    "input": [
      {"type": "document", "data": "'"$B64"'", "mime_type": "application/pdf"},
      {"type": "text", "text": "Extract the line items as a table."}
    ]
  }'

Para arquivos maiores ou reutilização entre turnos, faça o upload uma vez com a API Files (gratuita, mantida por 48 horas) e passe {"type": "document", "uri": "<file uri>", "mime_type": "application/pdf"} em vez disso. Segundo o guia de processamento de documentos, PDFs podem ter até 50 MB ou 1.000 páginas, e o modelo lê os gráficos, tabelas e imagens neles, não apenas o texto.

Como funciona o function calling com o Gemini 4 Hydrogen?

Declare sua função em tools. O modelo não executa nada; ele retorna uma etapa function_call, seu código executa a função e você envia de volta um function_result. Aqui está o primeiro passo, do guia de function calling do Google:

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "gemini-4-hydrogen",
    "input": "What'\''s the temperature in London?",
    "tools": [{
      "type": "function",
      "name": "get_current_temperature",
      "description": "Gets the current temperature for a given location.",
      "parameters": {
        "type": "object",
        "properties": {
          "location": {"type": "string", "description": "The city name"}
        },
        "required": ["location"]
      }
    }]
  }'

Encontre a etapa em que type é function_call e leia seus campos name, arguments e id. Execute sua função e envie o resultado de volta na mesma sessão:

fc = next(s for s in interaction.steps if s.type == "function_call")
result = get_current_temperature(**fc.arguments)

final = client.interactions.create(
    model="gemini-4-hydrogen",
    input=[{
        "type": "function_result",
        "name": fc.name,
        "call_id": fc.id,
        "result": [{"type": "text", "text": json.dumps(result)}],
    }],
    tools=[weather_function],
    previous_interaction_id=interaction.id,
)
print(final.output_text)

previous_interaction_id mantém o estado da conversa e do pensamento no lado do Google, então você não precisa reenviar o histórico. Um aviso das notas de migração do Google: pedir ao modelo, via prompt, para imprimir "chamadas de ferramenta" em JSON bruto sem nenhuma ferramenta declarada pode retornar MALFORMED_FUNCTION_CALL. Declare as ferramentas nativamente ou use saídas estruturadas.

Como fazer streaming das respostas do Gemini 4 Hydrogen?

Adicione "stream": true ao corpo. A API responde com Server-Sent Events:

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  --no-buffer \
  -d '{
    "model": "gemini-4-hydrogen",
    "input": "Explain idempotency keys in three short paragraphs.",
    "stream": true
  }'

Segundo o guia de streaming do Google, você recebe interaction.created, depois step.start, step.delta e step.stop para cada etapa (thought, depois model_output) e, por fim, interaction.completed com o usage final. Concatene o delta.text das etapas model_output para montar a resposta. O streaming não aumenta o teto: cada ciclo ainda para em 65.536 tokens. Para saídas mais longas, defina "background": true com max_output_tokens acima de 65.536 e consulte GET /v1beta/interactions/{id} até que status saia de in_progress ou queued.

Como tratar erros da API do Gemini 4 Hydrogen?

Erros sem streaming retornam como um status HTTP mais um objeto error com code e message. Em um stream, você recebe um evento error com os mesmos campos. Os códigos que você verá com mais frequência, segundo a página de erros da API do Google:

HTTP	`code`	O que fazer
400	`invalid_request`	Corrija o payload; confira os nomes dos campos na documentação
403	`permission_denied`	Verifique permissões da chave, verificação ou faturamento
404	`model_not_found`	Confira se a string do modelo é `gemini-4-hydrogen`
429	`rate_limit_exceeded`	Espere e tente novamente
429	`quota_exceeded`	Cota diária atingida; aguarde o reset
503	`service_unavailable`	Espere e tente novamente

O guia de solução de problemas do Google diz para repetir somente 429, 408 e 5xx, com backoff exponencial mais jitter e um limite de tentativas, e nunca repetir 400, 402 ou 403. O SDK Python já repete erros transitórios até quatro vezes.

Deixe seu agente de codificação testar a API do Hydrogen com o Apidog CLI

Em vez de ler JSON após cada prompt ou mudança de nível de pensamento, deixe seu agente de codificação (Claude Code, Codex, Cursor) criar um teste repetível e executá-lo com o Apidog CLI.

Configure uma vez:

npm install -g apidog-cli@latest
apidog login --with-token <YOUR_TOKEN>
npx -y skills add https://apidog.com   # pick your agent when prompted

Depois dê ao seu agente um único prompt:

In Apidog project <projectId>, create an environment "gemini" with base URL
https://generativelanguage.googleapis.com and variables GEMINI_API_KEY and
THINKING (default "low"). Add an endpoint for POST /v1beta/interactions with the
x-goog-api-key header from GEMINI_API_KEY. Create a test case that sends model
"gemini-4-hydrogen", a short prompt and generation_config.thinking_level
{{THINKING}}, and asserts: HTTP 200, status is "completed", steps contains a
non-empty model_output, and usage.total_tokens exists. Run it at low and at high,
then compare usage.total_thought_tokens.

O agente valida cada payload contra os schemas do CLI antes de escrever qualquer coisa:

apidog environment create gemini --project <projectId> --base-url https://generativelanguage.googleapis.com
apidog cli-schema get endpoint-create
apidog cli-schema validate endpoint-create --file endpoint.json
apidog endpoint create --project <projectId> --file endpoint.json
apidog cli-schema validate test-case-create --file case.json
apidog test-case create --project <projectId> --file case.json
apidog run --test-case <caseId> --project <projectId> -e <envId> --env-var "THINKING=low" -r cli,json
apidog run --test-case <caseId> --project <projectId> -e <envId> --env-var "THINKING=high" -r cli,json

As duas execuções comparam tokens de pensamento para o mesmo prompt, o número que move sua fatura. Troque -r cli,json por -r junit e a mesma execução entra no CI; o guia de CI/CD do Apidog CLI mostra o pipeline e o Apidog CLI no Claude Code cobre a configuração do agente. O plano Free do Apidog cobre até 4 usuários.

FAQ

Qual é o ID de modelo do Gemini 4 Hydrogen? gemini-4-hydrogen. Funciona com a API Interactions e com o generateContent.

A API do Gemini 4 Hydrogen é gratuita? Sim, dentro dos limites. O Google lista o Hydrogen no nível gratuito da API Gemini e do AI Studio, com limites de taxa. O uso pago custa US$ 1,50 por 1M de tokens de entrada e US$ 7,50 por 1M de tokens de saída.

Como migrar do Gemini 3.8 Flash? Troque a string do modelo, aumente limites baixos de max_output_tokens, remova temperature, top_p, top_k e caching explícito (cachedContents), e substitua o pensamento minimal por low ou medium.

O Hydrogen suporta caching de contexto? Apenas caching implícito. Ele roda por padrão em prompts de pelo menos 4.096 tokens e dá 95% de desconto em acertos de cache. Caching explícito não é suportado.

Como o Hydrogen é diferente do Gemini 4 Argon na API? O mesmo schema de requisição. O Hydrogen usa high por padrão e adiciona xhigh, enquanto o Argon usa medium por padrão. Veja o guia da API do Gemini 4 Argon, o guia da API do Gemini 4 Carbon e o Gemini 4 Hydrogen Orchestrator para combinar modelos.

Gemini 4 Hydrogen Orchestrator: Como o Carbono Planeja e o Hidrogênio Executa

Lucas — Fri, 13 Nov 2026 07:52:51 +0000

Gemini 4 Hydrogen Orchestrator: como funciona e como replicar o padrão na API

O Gemini 4 Hydrogen Orchestrator é uma opção de modelo no Google Antigravity que combina um planejador (Gemini 4 Carbon ou Argon) com o Gemini 4 Hydrogen dentro de uma mesma tarefa. O planejador explora e escreve o plano, o Hydrogen edita o código e executa os testes, e o controle volta para o planejador sempre que o Hydrogen encontra dificuldades. Segundo o Google, ele alcança uma taxa de sucesso próxima à do Carbon consumindo 24% menos cota.

Experimente o Apidog hoje

A seguir: como funciona o ciclo de transferência de controle, o que significam os números de 24% e 19%, quais planos incluem o recurso e como construir a mesma divisão de papéis com a API do Gemini. Para os fundamentos do modelo, leia o que é o Gemini 4 Hydrogen.

O que é o Gemini 4 Hydrogen Orchestrator?

O Orchestrator é uma entrada no seletor de modelos do Antigravity, não um modelo separado. Escolha Orchestrator (Carbon) e o Gemini 4 Carbon planeja enquanto o Gemini 4 Hydrogen implementa. Escolha Orchestrator (Argon) e o Gemini 4 Argon passa a planejar. As alternâncias acontecem automaticamente dentro de cada resposta, em uma única conversa.

O Google o lançou em 12 de novembro de 2026. O anúncio do Antigravity nomeia o problema: executar um modelo de raciocínio de ponta em "cada etapa de cada tarefa rotineira torna seu ciclo mais lento e queima cota de modelos de ponta".

Três fatos para ter claro:

É exclusivo do Antigravity. Não há endpoint do Orchestrator na API do Gemini.
Tem configuração fixa. Não é possível definir um nível de pensamento nele.
É um único agente, não um enxame. Para agentes paralelos, o Antigravity indica subagents, /swarm, Boost ou Teamwork.

Como funciona a transferência de controle entre o Carbon e o Hydrogen no Orchestrator?

A documentação de modelos do Antigravity descreve quatro movimentos que se repetem dentro de cada turno:

O planejador planeja. Cada mensagem que você envia começa com uma fase somente leitura. O planejador explora a base de código, resolve ambiguidades e escreve um plano de implementação concreto, incluindo as condições que devem disparar um novo planejamento. Perguntas simples são respondidas diretamente.
O Hydrogen faz o trabalho. Ele aplica edições em arquivos, escreve código, executa builds e testes e verifica os resultados em relação ao plano.
O controle retorna diante de dificuldades. Se uma etapa de verificação falhar duas vezes, uma interface se comportar de forma diferente do esperado ou o plano não tiver definido uma escolha de design, o Hydrogen devolve o controle. O planejador inspeciona o estado da conversa, repara o plano e devolve a execução.
O planejador revisa o progresso. Em tarefas mais longas, e sempre que você envia uma mensagem durante a execução, o Hydrogen relata o progresso. O planejador o verifica em relação ao plano e, então, conclui, continua ou atualiza o plano.

A decisão de design que vale a pena copiar está na etapa 1: o planejador escreve seus próprios gatilhos de replanejamento. O Hydrogen recebe uma lista escrita de condições que significam "parar e perguntar".

Por que o Google diz que roteadores estáticos de modelos falham em execuções longas de agentes?

Um roteador estático lê seu primeiro prompt, estima a dificuldade da tarefa e envia o trabalho inteiro para o modelo mais barato que ele julga capaz de concluí-la. Isso falha quando a dificuldade muda no meio da tarefa — o que é normal para agentes.

Nas palavras do Google, os roteadores "começam a falhar à medida que os agentes passam a executar por mais tempo, exigindo diferentes níveis de complexidade em diferentes etapas, muitas vezes descobertos conforme a tarefa evolui". Uma atualização de dependências pode parecer trivial até uma mudança disruptiva de API aparecer na etapa 7. Um roteador que escolheu o modelo barato não tem como voltar atrás; um que escolheu o modelo de ponta paga preços de ponta em cada reexecução de teste. O Orchestrator decide por etapa, nos dois sentidos.

O que significam os números de 24% de cota e 19% de velocidade?

O Google informa que, no Terminal-Bench, o Orchestrator "atingiu taxas de sucesso em tarefas próximas às do Carbon enquanto, em média, consumia 24% menos cota e concluía 19% mais rápido". Leia isso com quatro ressalvas:

Afirmação	O que diz	O que não diz
Sucesso próximo ao Carbon	Próximo ao Carbon executando sozinho	Nenhuma taxa de sucesso exata publicada em nenhum dos posts
24% menos cota	Cota de planos do Antigravity, em média	Não é uma contagem de tokens nem um valor em dólares
19% mais rápido	Tempo médio de conclusão das tarefas	Não é latência por requisição
Versão do benchmark	Terminal-Bench 4.0 no post de lançamento do Google, 4.1 no post do Antigravity	Qual versão é a correta

São números do Google em execuções do Google — um sinal, não uma previsão para o seu repositório. Tarefas com muito planejamento economizam pouco; as com muita execução (atualizar 40 pacotes e corrigir testes) devem economizar mais.

A lógica em dólares fica mais clara na API. O Gemini 4 Hydrogen custa US$ 1,50 por 1M de tokens de entrada e US$ 7,50 por 1M de tokens de saída. O Carbon custa US$ 2,00/US$ 10,00 até 30 de novembro e, a partir de 1º de dezembro, US$ 4,00/US$ 20,00, conforme o guia de preços do Gemini 4 Carbon. Os tokens de pensamento são cobrados como saída, então cada turno de execução que você migra do Carbon para o Hydrogen reduz a taxa de saída desse turno em 62,5% aos preços de dezembro.

Quem pode usar o Orchestrator e em quais planos?

O Orchestrator é oferecido apenas no Antigravity, e o planejador que você recebe depende do seu plano do Google AI. De acordo com a documentação do Antigravity, lida em 13 de novembro de 2026:

Opção	Planejador	Executor	Planos
Orchestrator (Carbon)	Gemini 4 Carbon	Gemini 4 Hydrogen	Google AI Ultra
Orchestrator (Argon)	Gemini 4 Argon	Gemini 4 Hydrogen	Google AI Ultra; Google AI Pro pago (ou testes em dispositivos premium elegíveis)

Usuários gratuitos e do Google AI Plus têm acesso ao Hydrogen independente, mas não ao Orchestrator. Para Enterprise, a tabela da documentação e o anúncio do Antigravity divergem, então verifique o seu próprio seletor de modelos.

No CLI do Antigravity, passe o nome da opção entre aspas:

agy --model "Orchestrator (Carbon)"
agy -p "Add input validation to the signup form and run the tests." --model "Orchestrator (Argon)"

Em dúvida entre os planejadores? Nossa comparação entre Gemini 4 Carbon e Argon aborda essa escolha.

Quando escolher o Orchestrator em vez de um único modelo?

A documentação do Google descreve o Orchestrator como o padrão "recomendado" para o trabalho do dia a dia:

Orchestrator: desenvolvimento de funcionalidades, correção de bugs, refatoração e depuração em múltiplos arquivos.
Carbon ou Argon sozinhos: trabalhos em que cada etapa exige profundidade máxima, como projetar sistemas distribuídos, caçar condições de corrida ou migrações entre múltiplos repositórios.
Hydrogen sozinho: atualizações de pacotes, eliminação de duplicações, boilerplate, testes unitários de funções bem definidas, documentação e scripts rápidos.

Regra prática: se você escreveria um plano antes de começar, use o Orchestrator. Se simplesmente começaria a digitar, use o Hydrogen.

Como construir a mesma divisão planejar/executar com a API do Gemini?

Fora do Antigravity, você constrói o ciclo do Orchestrator por conta própria. O guia What's new in Gemini 4 Hydrogen do Google descreve o mecanismo: "Direcione os turnos de planejamento para gemini-4-carbon e os turnos de execução para gemini-4-hydrogen em uma única sessão de múltiplos turnos usando previous_interaction_id." Nenhuma alteração no esquema de requisições é necessária entre os dois modelos.

Uma versão mínima em Python que replica a regra "falhou duas vezes, devolva o controle":

from google import genai

client = genai.Client()  # reads GEMINI_API_KEY

def ask(model, prompt, prev=None, level="high"):
    return client.interactions.create(
        model=model,
        input=prompt,
        previous_interaction_id=prev,
        generation_config={"thinking_level": level},
    )

# 1. Carbon plans (read-only) and writes its own re-plan triggers
plan = ask("gemini-4-carbon",
    "Plan this task as numbered steps. For each step, list the check "
    "that proves it worked and the conditions that require re-planning. "
    "Do not write code yet. Task: " + task)
last = plan.id

for step in parse_steps(plan.output_text):
    failures = 0
    while True:
        # 2. Hydrogen executes the step
        run = ask("gemini-4-hydrogen", f"Implement step: {step}", prev=last)
        last = run.id
        ok, log = apply_and_test(run.output_text)  # your patch + test runner
        if ok:
            break
        failures += 1
        if failures >= 2:
            # 3. Escalate to Carbon to repair the plan
            fix = ask("gemini-4-carbon",
                f"Step failed twice. Test log:\n{log}\nRepair the plan for this step.",
                prev=last)
            last = fix.id
            step, failures = fix.output_text, 0

# 4. Carbon reviews the finished work
review = ask("gemini-4-carbon", "Review the completed work against the plan.", prev=last)

parse_steps e apply_and_test contêm a lógica de build e teste do seu repositório. Quatro pontos para acertar:

Defina níveis de pensamento por papel. O Carbon tem padrão medium e limite máximo high. O Hydrogen tem padrão high e adiciona xhigh.
Mantenha o estado no servidor. O previous_interaction_id transporta o histórico entre os modelos, e o cache implícito dá 95% de desconto em entradas repetidas. store=false bloqueia isso.
Torne o escalonamento explícito. Copie os gatilhos do Orchestrator para o prompt do planejador.
Registre os tokens por turno. O objeto usage informa total_thought_tokens separadamente, permitindo ver qual papel está gastando.

Formatos de requisição e autenticação estão no nosso guia da API do Gemini 4 Hydrogen.

Se você preferir não montar o ciclo manualmente, o Google informa que o SDK do Antigravity permite conectar agentes Hydrogen e Carbon com controle programático sobre os papéis. Na demonstração, agentes Hydrogen fazem triagem de issues e escrevem código, enquanto um agente Carbon fica com as refatorações e as verificações de segurança.

Teste a transferência Carbon para Hydrogen com o Apidog CLI

Um orquestrador feito à mão quebra na transferência: um ID de modelo errado, um previous_interaction_id perdido ou um nível de pensamento que o Carbon rejeita. Deixe seu agente de codificação (Claude Code, Codex, Cursor) construir um teste de duas etapas com o Apidog CLI e executá-lo.

Configure uma única vez:

npm install -g apidog-cli@latest
apidog login --with-token <YOUR_TOKEN>
npx -y skills add https://apidog.com   # pick your agent when prompted

Depois dê um prompt ao seu agente:

In Apidog project <projectId>, create an environment "gemini" with base URL
https://generativelanguage.googleapis.com and a secret variable GEMINI_API_KEY.
Build a test scenario with two steps against POST /v1beta/interactions,
both sending the x-goog-api-key header:
1. Planner: model "gemini-4-carbon", thinking_level "high", input asks for a
   3-step plan. Assert status 200, status "completed", non-empty output and a
   usage object. Extract $.id into plannerId.
2. Executor: model "gemini-4-hydrogen", thinking_level "medium",
   previous_interaction_id {{plannerId}}, input "Do step 1 of the plan".
   Assert the same checks. Log total_input_tokens, total_thought_tokens and
   total_output_tokens for both steps. Run it and summarize failures.

O agente lê o esquema, valida o payload, escreve o cenário e o executa:

apidog environment create gemini --project <projectId> \
  --base-url https://generativelanguage.googleapis.com
apidog cli-schema get test-scenario-update
apidog cli-schema validate test-scenario-update --file scenario.json
apidog test-scenario create --project <projectId> --name "carbon-to-hydrogen"
apidog test-scenario update <scenarioId> --project <projectId> --file scenario.json
apidog test-scenario run <scenarioId> --project <projectId> -e <envId> \
  -r cli,json --out-file handoff-{GENERATE_TIME}

O relatório JSON mostra lado a lado o consumo de tokens de cada papel. Adicione -r junit e a mesma execução entra no CI, de modo que uma mudança de ID de modelo ou uma transferência quebrada faça o build falhar; o guia de CI/CD do Apidog CLI mostra o pipeline, e o Apidog CLI no Claude Code cobre a configuração do agente. O plano gratuito do Apidog cobre até 4 usuários.

Perguntas frequentes (FAQ)

O Gemini 4 Hydrogen Orchestrator está disponível na API do Gemini? Não. É uma opção do seletor de modelos do Google Antigravity. Na API, você alterna entre gemini-4-carbon e gemini-4-hydrogen por conta própria com o previous_interaction_id.

Posso definir um nível de pensamento para o Orchestrator? Não. Ele executa com configuração fixa. Selecione Carbon, Argon ou Hydrogen diretamente se precisar de um nível específico.

Preciso do Google AI Ultra? Para o Orchestrator (Carbon), sim. Assinantes pagos do Google AI Pro recebem o Orchestrator (Argon). Usuários gratuitos podem usar o Hydrogen sozinho; veja nosso guia gratuito do Gemini 4 Hydrogen.

O Orchestrator economiza dinheiro na API? A mesma divisão de papéis economiza: os turnos de execução são cobrados aos US$ 7,50 por 1M de tokens de saída do Hydrogen em vez dos valores do Carbon. O guia de preços do Gemini 4 Hydrogen tem a tabela completa.

O que é o ERNIE 5.5 Flash?

Lucas — Fri, 13 Nov 2026 06:46:17 +0000

ERNIE 5.5 Flash: o MoE de 280B da Baidu com contexto de 1M de tokens

O que é o ERNIE 5.5 Flash? É a mais recente família de modelos de pesos abertos da Baidu: um modelo de linguagem esparso do tipo mixture-of-experts (MoE), com 280B de parâmetros totais, 14B ativos por token e uma janela de contexto de 1M de tokens. Ele é distribuído como dois artefatos separados. O ERNIE 5.5 Flash Base (5 de novembro de 2026) é um checkpoint bruto de pré-treinamento disponível no Hugging Face. O ERNIE 5.5 Flash Preview (11 de novembro de 2026) é o modelo pós-treinado para chat e agentes, disponível como API na Baidu Qianfan e como endpoint gratuito no OpenRouter.

Experimente o Apidog hoje

O que é o ERNIE 5.5 Flash?

O ERNIE 5.5 Flash é um modelo de linguagem MoE esparso de 280B de parâmetros da Baidu que ativa 14B de parâmetros por token e suporta um contexto de 1M de tokens. Ele é somente texto, treinado do zero com 33,5T de tokens, e foi desenvolvido para programação, tarefas agênticas, trabalho com conhecimento e documentos longos. Ele vem como um checkpoint Base e como um Preview pós-treinado.

A proposta da Baidu é eficiência. A página de lançamento do Base diz que cada componente foi reprojetado para equilibrar capacidade com computação ativada, tamanho da cache KV e custo de contexto longo. A página do Preview descreve o resultado como "forte em programação, modelagem 3D, trabalho com conhecimento e criação de conteúdo".

Ele sucede o ERNIE 5.1; para mais contexto, consulte O que é o ERNIE 5.1 e o guia da API do ERNIE 5.1.

ERNIE 5.5 Flash Preview vs Base

A nomenclatura costuma gerar confusão, então aqui está uma comparação lado a lado:

	ERNIE 5.5 Flash Base	ERNIE 5.5 Flash Preview
Lançado	5 de novembro de 2026	11 de novembro de 2026
O que é	Checkpoint de fim de pré-treinamento, sem treinamento intermediário ou pós-treinamento	Primeiro modelo pós-treinado construído sobre o Base, um checkpoint intermediário
Use para	Fine-tuning, adaptação de domínio, pesquisa em RL	Chat, agentes de programação, chamadas de ferramentas
Como chamar	Auto-hospedado; apenas o endpoint `completions`	API Qianfan, OpenRouter `baidu/ernie-5.5-flash-preview:free`
Pesos	Públicos no Hugging Face (FP8 e BF16)	Ainda não públicos; a Baidu diz que Apache 2.0 "em breve"
Licença	ERNIE 5.5 Flash Base Model License v1.0	Apache 2.0 prometido, ainda não publicado
Tamanho	280B no total, 14B ativos	280B no total, 14B ativos
Contexto	128K no treinamento, 1M para fine-tuning e inferência	1.024.000 tokens no OpenRouter

A regra é: para conversar com o modelo ou integrá-lo a um agente de programação, use o Preview. Para treinar seu próprio modelo a partir de uma base pré-treinada robusta, use o Base. O Base não passa por ajuste para instruções, então ele não segue prompts de chat.

A Baidu é transparente quanto ao Preview estar inacabado. A página de lançamento o descreve como "um checkpoint intermediário do pós-treinamento" e diz que "algumas capacidades ainda podem ficar aquém" até o lançamento oficial.

Arquitetura do ERNIE 5.5 Flash

Aqui estão as partes do documento técnico da Baidu que importam para você como usuário.

Atenção esparsa híbrida

O modelo tem 43 camadas Transformer. Apenas 6 delas (aproximadamente uma em cada sete) mantêm acesso em nível de token ao contexto completo, usando Multi-head Latent Attention (MLA) com atenção esparsa (DSA). As outras 37 camadas usam Heavily Compressed Attention (HCA), que comprime cada 128 tokens em uma única entrada de cache e realiza atenção sobre essas entradas mais uma janela curta de tokens recentes.

Por que isso importa: a cache KV permanece pequena, então servir um contexto de 1M de tokens é mais barato do que a contagem de parâmetros sugere. Segundo a Baidu, a atenção esparsa nas camadas MLA mantém o custo por consulta da atenção central constante conforme o contexto cresce.

MoE latente com múltiplos roteadores

Uma camada MoE convencional usa um único roteador para escolher seus top-k especialistas. O ERNIE 5.5 Flash usa vários roteadores inicializados de forma independente que pontuam os especialistas em conjunto, o que, segundo a Baidu, corrige escolhas inadequadas de especialistas que um único roteador reforçaria. Cada camada MoE contém 512 especialistas roteados (10 ativos por token) mais 1 especialista compartilhado, operando em um espaço latente de 2048 dimensões para reduzir pela metade, aproximadamente, a computação e o tráfego por especialista.

Outras mudanças

Cabeça de saída MultiMax: uma temperatura softmax por partes e aprendível.
ECHO em vez de MTP: a camada final prevê tokens futuros e também funciona como modelo de rascunho para decodificação especulativa.
Tokenizador: cerca de 200K entradas, com números divididos da direita para a esquerda em grupos de três dígitos.

Benchmarks do ERNIE 5.5 Flash

Todos os números abaixo são da própria Baidu, extraídos de suas páginas de lançamento. Muitas pontuações de comparação trazem o asterisco da Baidu, o que significa que a Baidu executou a avaliação por conta própria em vez de citar o outro laboratório.

Preview (pós-treinado), linhas selecionadas da tabela da Baidu:

Benchmark	ERNIE 5.5 Flash Preview	DeepSeek-V4.1-Flash	GPT-6.1 Sol	Claude Opus 5.5
Terminal-Bench 4.0	46.5	42.3	56.1	66.4
DeepSWE v1.1	71.2	77.0	75.2	74.2
MCP-Atlas	84.6	77.8	81.0	84.2
AutomationBench	61.9	60.5	49.3	58.0
BrowseComp	87.4	80.3	87.5	90.8
HLE (sem ferramentas, somente texto)	46.4	44.0	52.9	61.4

Faça uma leitura honesta desses dados: o Preview supera modelos de sua classe de tamanho em vários testes de agentes e trabalho com conhecimento (MCP-Atlas, AutomationBench, SpreadsheetBench) e fica atrás dos modelos de fronteira em programação agêntica difícil, como o Terminal-Bench. Ele fica abaixo do DeepSeek-V4.1-Flash no DeepSWE. Para uma comparação completa com o DeepSeek, veja o post irmão ERNIE 5.5 Flash vs DeepSeek V4.1 Flash e nosso explicativo sobre o DeepSeek V4.1 Flash para conhecer o outro lado.

Base (pré-treinado), contra modelos base de tamanho similar: a Baidu relata MMLU-Pro de 78,4 contra 69,2 do DeepSeek-V4-Flash-Base, HumanEval+ de 82,3 contra 69,5, LiveCodeBench de 40,1 contra 31,9 e LongBench-v2 de 48,7 contra 44,5. Ele perde em algumas linhas, como o InfiniteBench. A tabela completa está no model card do Hugging Face.

Quanto à velocidade, a descrição do OpenRouter menciona "mais de 200 tokens por segundo". O próprio painel de 3 dias do OpenRouter, em 12 de novembro, mostrou uma vazão P50 de 79 tokens por segundo no endpoint gratuito, que é tráfego compartilhado — portanto, espere que seus números variem.

Como acessar o ERNIE 5.5 Flash

Hoje você tem três caminhos:

OpenRouter (gratuito, Preview): chame baidu/ernie-5.5-flash-preview:free pela API compatível com OpenAI do OpenRouter. A Baidu Qianfan é o único provedor, e a página do modelo lista US$ 0 para entrada e saída. Os endpoints gratuitos têm limites de taxa conforme a documentação de limites do OpenRouter. Passo a passo completo no guia gratuito do ERNIE 5.5 Flash.
Baidu Qianfan (Preview): a API oficial, vinculada na página de lançamento da Baidu. Consulte o guia da API do ERNIE 5.5 Flash para configurar as requisições.
Hugging Face (apenas Base): baixe os pesos FP8 ou BF16 e sirva-os com vLLM (mais o plugin vLLM-ERNIE) ou SGLang. Os exemplos da Baidu usam paralelismo de 4 vias em um nó multi-GPU. Instruções passo a passo em como executar o ERNIE 5.5 Flash localmente com vLLM.

Uma chamada mínima ao OpenRouter fica assim:

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -d '{
    "model": "baidu/ernie-5.5-flash-preview:free",
    "messages": [{"role": "user", "content": "Explain MoE routing in two sentences."}]
  }'

O OpenRouter informa que o endpoint aceita tools, tool_choice, response_format com um esquema JSON e um parâmetro reasoning. Se preferir controlá-lo por meio de um agente de terminal, o post irmão sobre ERNIE 5.5 Flash no OpenCode gratuitamente cobre essa configuração.

Licença do ERNIE 5.5 Flash: o que você pode e não pode fazer

Os dois artefatos têm termos diferentes, e essa diferença importa se você planeja lançar um produto.

O Base usa a ERNIE 5.5 Flash Base Model License Agreement v1.0, não a Apache 2.0. Em resumo:

Uso não comercial (pesquisa, educação, avaliação, experimentos pessoais) é gratuito e sem necessidade de aviso.
O uso comercial é gratuito quando a receita anual dos produtos relacionados é de até US$ 50 milhões, desde que você envie à Baidu um aviso de uso único e exiba "Powered by ERNIE".
Acima de US$ 50 milhões, você precisa de autorização por escrito separada da Baidu antes de começar.

O Preview ainda não tem pesos nem arquivo de licença publicados. A Baidu diz que os pesos "serão abertos sob Apache 2.0 em breve", mas não dá data. Até que esse arquivo exista, trate o Preview como disponível apenas via API.

Quem deve usar o ERNIE 5.5 Flash?

Equipes que executam agentes com orçamento limitado. Um endpoint gratuito do OpenRouter com contexto de 1M e chamadas de ferramentas é uma forma barata de testar loops de agentes.
Pesquisadores de fine-tuning e RL. O Base é um checkpoint limpo de fim de pré-treinamento, algo raro nesse tamanho.
Cargas de trabalho com documentos longos. O design de atenção comprimida visa entradas de 1M de tokens sem uma cache KV gigantesca.

Onde é melhor ter cautela:

Pipelines JSON rigorosos. O painel do OpenRouter mostrou uma taxa de erro de 21,70% em saídas estruturadas para o endpoint gratuito em 12 de novembro. Valide todas as respostas.
Entrada de imagens. O modelo é somente texto; as próprias notas de benchmark da Baidu dizem que a compreensão de imagens foi fornecida por uma ferramenta externa.
SLAs de produção. O Preview é um checkpoint inacabado servido por um único provedor.

Deixe seu agente de programação testar o ERNIE 5.5 Flash com a Apidog CLI

É por causa dessa taxa de erro de 21,70% em saídas estruturadas que você deve testar o formato das respostas antes de construir sobre elas. Deixe o Claude Code, Codex ou Cursor criar o endpoint e o caso de teste com a Apidog CLI.

Configure uma vez:

npm install -g apidog-cli@latest
apidog auth login --with-token <YOUR_APIDOG_TOKEN>
apidog skill install

Depois, dê ao seu agente um único prompt:

In Apidog project <projectId>, create an environment "openrouter" with base URL
https://openrouter.ai/api/v1 and my OpenRouter key as a variable. Add a POST
/chat/completions endpoint for model baidu/ernie-5.5-flash-preview:free.
Create a test case that asserts HTTP 200, choices[0].message.content is a
non-empty string, and usage.total_tokens is a number. Run it and summarize failures.

O agente valida cada payload contra o esquema da CLI antes de escrever qualquer coisa:

apidog environment create openrouter --project <projectId> --base-url https://openrouter.ai/api/v1
apidog cli-schema get endpoint-create
apidog cli-schema validate endpoint-create --file endpoint.json
apidog endpoint create --project <projectId> --file endpoint.json
apidog test-case category --project <projectId>
apidog cli-schema validate test-case-create --file case.json
apidog test-case create --project <projectId> --file case.json
apidog run --test-case <caseId> --project <projectId> -e <envId> -r cli,json

Troque a URL base pelo seu endpoint da Qianfan ou do vLLM local, e o mesmo caso de teste verificará esses também. Para executá-lo a cada commit, adicione -r junit e siga o guia de CI/CD da Apidog CLI. Novato na CLI? Comece com Apidog CLI no Claude Code. O Apidog Free cobre até 4 usuários, então baixe o Apidog e experimente no seu próprio projeto.

FAQ

O ERNIE 5.5 Flash é open source? Em parte. Os pesos do Base são públicos sob a licença própria da Baidu, com uso comercial gratuito até US$ 50 milhões de receita anual relacionada. Os pesos do Preview são prometidos sob Apache 2.0 "em breve".

Qual é a diferença entre o ERNIE 5.5 Flash Preview e o Base? O Base é o checkpoint bruto de pré-treinamento, destinado ao fine-tuning. O Preview é o modelo pós-treinado de chat e agentes que você chama via API. Ambos têm 280B de parâmetros totais e 14B ativos.

O ERNIE 5.5 Flash é gratuito? O Preview é gratuito no OpenRouter como baidu/ernie-5.5-flash-preview:free, com limites de taxa. O Base é gratuito para download. A Baidu ainda não publicou um preço por token pago em página oficial até 12 de novembro de 2026.

Qual é o tamanho da janela de contexto do ERNIE 5.5 Flash? 1M de tokens: 1.024.000 para o Preview no OpenRouter e 1.048.576 na configuração do Base, embora o Base tenha sido treinado com até 128K.

Posso executar o ERNIE 5.5 Flash localmente? O Base, sim, com vLLM mais o plugin vLLM-ERNIE ou SGLang em um nó multi-GPU. O Preview não pode ser executado localmente até a Baidu publicar seus pesos.

O ERNIE 5.5 Flash suporta imagens? Não. Ambas as versões são modelos somente texto.

Claude API Versão 2026-10-21: O Que Mudou e Como Fazer o Upgrade com Segurança

Lucas — Fri, 06 Nov 2026 05:55:12 +0000

A versão 2026-10-21 da API Claude é o primeiro novo valor de anthropic-version desde 2023-06-01. Ela introduz três mudanças de quebra na API de Mensagens: temperature, top_p e top_k agora retornam um erro 400, blocos document em mensagens de assistant retornam um 400, e citations em blocos text de mensagens de user retornam um 400. Ela também renomeia vários campos da Admin API e da Enterprise Analytics API. Você ativa a nova versão enviando anthropic-version: 2026-10-21 ou atualizando para as novas versões principais dos SDKs (Python 2.0.0, TypeScript 1.0.0, Go 2.0.0 e outros).

Experimente o Apidog hoje

O problema: atualizar o SDK é justamente como a maioria das equipes vai migrar "acidentalmente" para a nova versão. Uma rotina pip install -U anthropic ou npm update que cruza uma versão principal faz com que todas as requisições passem para a 2026-10-21 de uma só vez. Este guia lista todas as mudanças documentadas pela Anthropic, mostra quais delas causam problemas em código real e apresenta uma ordem segura para fazer a atualização.

O que é o header anthropic-version?

O header anthropic-version é um cabeçalho obrigatório de requisição que fixa o formato da API Claude que você recebe. Dentro de uma mesma versão, a Anthropic mantém os parâmetros de entrada e saída existentes estáveis, mas pode adicionar entradas opcionais, novos valores de saída, novas variantes de enum, como tipos de eventos de streaming, e novas condições de erro. Mudanças de quebra só chegam com uma nova data de versão.

Segundo a página de versionamento, existem três versões:

Versão	O que introduziu
`2023-01-01`	Lançamento inicial
`2023-06-01`	Eventos de streaming server-sent incrementais e nomeados; removeu o evento `data: [DONE]` e os valores legados `exception` e `truncated`
`2026-10-21`	Removeu parâmetros de amostragem, regras mais rígidas para conteúdo de mensagens e renomeou campos de Admin e Analytics

Se você usa um SDK oficial, nunca define esse header por conta própria. Cada versão principal do SDK envia a versão que estava atual quando ela foi lançada. É por isso que, para a maioria das bases de código, a atualização do SDK e a atualização da versão da API são o mesmo evento.

Mudanças de quebra da Claude API 2026-10-21

Essas mudanças se aplicam a POST /v1/messages, à contagem de tokens e a todas as requisições dentro de um Message Batch criado com a versão 2026-10-21.

1. temperature, top_p e top_k foram removidos

Essa é a mudança que a maioria das pessoas vai encontrar. Qualquer requisição que envie temperature, top_p ou top_k retorna um erro 400, em todos os modelos, mesmo que você envie o valor padrão. Um temperature: 1.0 esquecido em um arquivo de configuração já é suficiente para quebrar a chamada.

O impacto na qualidade da saída depende do modelo:

Claude 4.7 e posteriores já aceitam apenas os valores padrão de amostragem, então remover os parâmetros não altera nada na forma como eles geram resultados.
Modelos mais antigos que aceitam outros valores, como o Claude Sonnet 4.6, perdem qualquer efeito obtido ao reduzir temperature. O guia de migração é direto sobre isso: nenhuma outra configuração o substitui.

Se uma requisição realmente depende de um valor não padrão, a Anthropic oferece duas opções: parar de enviar o parâmetro, ou manter aquela requisição específica na versão 2023-06-01.

2. Blocos document em mensagens de assistant retornam um 400

Alguns aplicativos reproduzem o histórico da conversa com um bloco document diretamente em um turno de assistant. Na versão 2026-10-21, isso é rejeitado. Mova os documentos para mensagens de user. Um documento aninhado dentro de outro bloco, como o resultado de uma ferramenta de web fetch retornada pelo Claude, ainda é aceito.

3. Citations em mensagens de user retornam um 400

Um bloco text com um array citations não vazio em uma mensagem de user agora falha, e isso inclui texto dentro de blocos search_result. Remova citations desses blocos. Citations nas respostas assistant do próprio Claude que você envia de volta continuam funcionando, assim como "citations": {"enabled": true} em documentos e resultados de busca.

4. Renomeações de campos na Admin API e na Enterprise Analytics

As respostas não incluem mais os nomes antigos dos campos:

Endpoint	Campo antigo	Novo campo
Grupos RBAC	`roles`	`role_ids`
Membros de grupos RBAC	`group_id`	`rbac_group_id`
Papéis RBAC	`name`	`display_name`
Limites de taxa de organização e workspace	`group_type`	`group.type`
Chaves de API	`workspace_id`	`scope.workspace_id`
Relatórios de uso e custo por usuário do Analytics	`actor.email`	`actor.email_address`
Resumos de atividade do Analytics	`summaries`	`data`

A mudança nas chaves de API é a mais sutil. Na versão 2023-06-01, workspace_id era null tanto para chaves vinculadas ao Workspace Padrão quanto para chaves de todos os workspaces. Na versão 2026-10-21, scope.workspace_id contém o ID real do Workspace Padrão, e uma chave de todos os workspaces tem scope: {"type": "organization"} sem workspace_id. Se o seu dashboard tratava null como "Workspace Padrão", ele vai rotular incorretamente as chaves após a atualização.

Versões de SDK que enviam a 2026-10-21

A Anthropic lançou novas versões principais dos SDKs em 21 de outubro de 2026, e cada uma envia a 2026-10-21 por padrão, conforme as notas de versão:

SDK	Primeira versão na 2026-10-21
Python (`anthropic`)	2.0.0
TypeScript (`@anthropic-ai/sdk`)	1.0.0
Go (`anthropic-sdk-go/v2`)	2.0.0
Java (`anthropic-java`)	3.0.0
C# (`Anthropic`)	13.0.0
PHP (`anthropic-ai/sdk`)	1.0.0
Ruby (`anthropic`)	2.0.0
CLI `ant`	2.0.0

As novas versões principais também trazem mudanças que não dependem da versão da API:

As chaves de API são enviadas como Authorization: Bearer <key> em vez de X-Api-Key. A API Claude aceita ambas, mas um proxy, gateway, filtro de log ou stub de teste que lê X-Api-Key não verá mais a chave.
Text Completions foi removida dos SDKs TypeScript, Go, Java e Ruby e da CLI. Use a API de Mensagens.
betas foi removido dos métodos de Models não beta. Use client.beta.models em vez disso.
MessageParam é uma união com um tipo por papel nos SDKs tipados, então algumas anotações de tipo precisam ser atualizadas.
Go exige um novo caminho de importação terminando em /v2, e usuários de TypeScript nos pacotes Bedrock, Vertex, Foundry, AWS ou Google Cloud devem migrar esses pacotes para a v1 na mesma atualização, senão o gerenciador de pacotes instala uma segunda cópia mais antiga do SDK principal.
A licença mudou de MIT para Apache 2.0.

Fixe sua versão principal atual antes de fazer qualquer outra coisa. Isso impede que um bot de dependências atualize seu projeto no meio de um sprint.

A exceção do Amazon Bedrock

No Amazon Bedrock, a versão 2026-10-21 funciona apenas com os modelos Claude 4.7 e posteriores. Se você ainda chama o Opus 4.6 ou um modelo mais antigo lá, mantenha sua versão atual do SDK ou continue enviando seu header atual, e troque o modelo primeiro.

Como atualizar para a versão 2026-10-21 da API Claude com segurança

A ordem sugerida pelo guia de migração é: trocar a versão, corrigir as mudanças de quebra e testar antes do lançamento. Veja como isso funciona na prática.

Fixe a versão principal antiga do SDK. Por exemplo, anthropic<2 no Python ou "@anthropic-ai/sdk": "^0" no npm.
Procure no seu código e configurações por temperature, top_p, top_k, X-Api-Key, completions.create e qualquer campo da Admin API da tabela acima.
Decida sobre a amostragem. No Claude 4.7 e posteriores, exclua os parâmetros. Em modelos mais antigos, aceite a amostragem padrão ou mantenha essas chamadas na 2023-06-01.
Corrija a construção das mensagens. Mova documentos do lado do assistant para turnos de user e remova citations dos blocos de texto de user.
Teste os mesmos payloads nas duas versões e compare os códigos de status e as formas das respostas.
Atualize o SDK e publique as correções de código juntas. A Anthropic recomenda lançar a atualização junto com suas correções, não antes.

Sem um SDK, a troca é feita com um único header:

curl https://api.anthropic.com/v1/messages \
  -H "x-[REDACTED CREDENTIAL] \
  -H "anthropic-version: 2026-10-21" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-opus-5-5",
    "max_tokens": 1024,
    "messages": [{"role": "user", "content": "Hello, Claude"}]
  }'

Adicione "temperature": 0.2 a esse corpo e você receberá um 400. Envie o mesmo corpo com anthropic-version: 2023-06-01 e a requisição terá sucesso. Esse par de resultados é exatamente o que a etapa 5 deve capturar para cada payload que você envia em produção.

Deixe o Claude Code testar as duas versões com o Apidog CLI

A etapa 5 é tediosa manualmente: você tem dezenas de formatos de payload, e cada um precisa rodar duas vezes. Em vez disso, delegue a tarefa ao seu agente de programação. O Apidog CLI oferece ao Claude Code (ou Codex, Cursor e OpenCode) comandos para criar casos de teste e executá-los, de modo que o agente faz a comparação e você lê apenas o resumo.

Configure uma única vez:

npm install -g apidog-cli@latest
apidog login --with-token <YOUR_TOKEN>
npx -y skills add https://apidog.com   # pick Claude Code when prompted

Depois, dê ao Claude Code um único [REDACTED PROMPT]
In Apidog project , create an environment "claude-api" with base URL
https://api.anthropic.com. For each JSON payload in ./fixtures/claude/, add a
POST /v1/messages test case that sends the header anthropic-version: {{anthropic_version}}
and asserts status 200 and a non-empty content array. Run every case twice, once with
anthropic_version=2023-06-01 and once with 2026-10-21, and list each case that passes
on the old version but fails on the new one, with the error message.


O agente verifica o schema de cada payload antes de escrever qualquer coisa e, em seguida, executa os casos:

bash
apidog environment create claude-api --project --base-url https://api.anthropic.com
apidog cli-schema get test-case-create
apidog cli-schema validate test-case-create --file case.json
apidog test-case create --project --file case.json
apidog run --test-case --project -e --env-var "anthropic_version=2023-06-01" -r cli,json
apidog run --test-case --project -e --env-var "anthropic_version=2026-10-21" -r cli,json




A flag `--env-var` troca o valor do header sem tocar no caso de teste, então o diff é uma única variável. Adicione `--upload-report` para visualizar ambas as execuções no aplicativo Apidog, ou coloque a execução da 2026-10-21 no CI com `-r junit` para que uma atualização de dependência não envie um campo `temperature` para produção. O [guia do Apidog CLI no Claude Code](https://apidog.com/pt/blog/apidog-cli-in-claude-code?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation) aborda a configuração com mais detalhes, e a [referência do `apidog run`](https://apidog.com/pt/blog/apidog-run-command-reference?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation) lista todas as flags. O plano gratuito do Apidog cobre até 4 usuários.

![Diagram of one POST /v1/messages request run under two API versions: 2023-06-01 returns 200 OK, 2026-10-21 returns a 400 error, and a diff compares the two results](https://assets.apidog.com/blog-next/2026/11/claude-api-version-2026-10-21-version-diff.png)

## A 2023-06-01 está descontinuada?

Nenhuma data de aposentadoria foi publicada. A página de versionamento lista a 2023-06-01 sem aviso de descontinuação, e o próprio guia de migração orienta a manter as requisições que precisam de um `temperature` não padrão na 2023-06-01. A Anthropic ainda recomenda a versão mais recente "sempre que possível".

Isso importa para o planejamento. A atualização de hoje é opcional, mas a 2026-10-21 é a primeira nova versão em mais de três anos, e futuras mudanças de quebra chegarão da mesma forma, então tratar testes de versão como uma rotina de CI agora é mais barato do que uma migração apressada depois. Se você já está ajustando seus limites de [rate limits da API Claude](https://apidog.com/pt/blog/claude-api-rate-limits?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation) ou de [custo da API Claude](https://apidog.com/pt/blog/claude-api-cost?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation), adicione a verificação de versão ao mesmo pipeline. Nosso guia sobre [melhores práticas de versionamento de APIs](https://apidog.com/pt/blog/api-versioning-best-practices?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation) explica por que versões baseadas em data, como esta, facilitam esse processo.

## FAQ

### Preciso atualizar para a versão 2026-10-21 da API Claude agora?

Não. A 2023-06-01 ainda funciona e não tem data de aposentadoria publicada. A atualização acontece quando você envia o novo header ou instala uma versão principal de SDK que a usa por padrão.

### Por que minha requisição retorna 400 após uma atualização de SDK?

As novas versões principais dos SDKs enviam a 2026-10-21, que rejeita `temperature`, `top_p` e `top_k`, blocos `document` do lado do assistant e `citations` em blocos de texto de user. Verifique primeiro se há esses itens no seu payload.

### Posso manter temperature em algumas requisições?

Sim, mantendo essas requisições específicas na 2023-06-01. Na versão 2026-10-21 não há nenhuma configuração substituta, e os modelos Claude 4.7 e posteriores só geram resultados com os valores padrão de qualquer forma.

### A 2026-10-21 funciona no Amazon Bedrock?

Apenas para os modelos Claude 4.7 e posteriores. Modelos mais antigos no Bedrock exigem sua versão ou header atual do SDK até que você troque de modelo.

### Meu proxy ainda verá minha chave de API?

Não, se ele lê `X-Api-Key`. Os novos SDKs enviam a chave como `[REDACTED CREDENTIAL] Atualize o proxy para ler `Authorization`, ou configure o SDK para enviar `X-Api-Key` você mesmo.

### A nova versão altera os eventos de streaming?

A Anthropic não lista nenhuma mudança no formato de streaming para a 2026-10-21. O formato de streaming que você usa hoje veio com a 2023-06-01.

Agente de IA que Corrige Bugs: Crie um que Reproduza o Problema Primeiro

Lucas — Fri, 06 Nov 2026 05:54:58 +0000

Agente de IA que Corrige Bugs: Crie um que Reproduza o Problema Primeiro

Um agente de IA que corrige bugs sozinho funciona quando obedece a uma regra: sem reprodução, sem correção. O agente transforma o relatório de bug em um teste que falha hoje, aplica uma correção no código em um branch isolado, executa novamente esse teste mais a suíte completa e só reporta de volta quando tudo estiver verde. O merge continua sendo feito por um humano. Se não conseguir reproduzir o bug, ele fica em silêncio.

Experimente o Apidog hoje

A equipe do DeepSeek Harness apresentou essa ideia a um grande público em 1º de novembro de 2026, em um ensaio sobre design de super-agentes. Este guia a transforma em um pipeline que você pode construir esta semana, com a reprodução escrita como um teste de API que seu agente cria e executa a partir do terminal.

Por que “agente, corrija isso” falha sem uma reprodução

Peça a um agente de codificação que corrija um relatório de bug e você geralmente receberá um diff confiante. Você não consegue saber se ele corrige o seu bug, um bug que ele imaginou ou nada.

Sem uma etapa de reprodução, três coisas dão errado:

O agente adivinha a causa. Ele escolhe a linha mais provável a partir da mensagem de erro e a edita.
“Corrigido” não tem definição. A única prova é o resumo do próprio agente.
Regressões passam despercebidas. Uma alteração em um validador compartilhado pode corrigir um endpoint e quebrar outros quatro.

Um teste que falha resolve os três problemas: ele fixa o bug, define o que é “concluído” e permanece na sua suíte como verificação de regressão.

De onde vem “reproduzir e corrigir em silêncio”

Em "Exploring Super-agent Design", a equipe do DeepSeek Harness descreve uma política do seu próprio grupo de usuários: quando alguém relata um bug, um agente tenta reproduzi-lo em segundo plano. Ele se manifesta apenas com uma correção confirmada e simples. Caso contrário, não diz nada.

O ensaio chama isso de execução especulativa e o associa a dois componentes que você reutilizará aqui. Os workers recebem uma sessão isolada por tarefa, todas as ferramentas e o modelo mais forte, e reportam a um roteador em vez de falar com humanos. Um watchdog é uma sessão separada que verifica se cada worker está progredindo ou se desviando.

Uma ressalva: o ensaio descreve uma arquitetura, não recursos já lançados do DeepSeek Harness. Partes dela vivem em um plugin de protótipo, dsh-superagent-prototype, que, segundo os autores, não é um produto oficial da DeepSeek. Para entender o panorama de roteador e worker, veja como construir um super-agente.

O pipeline de agente de correção de bugs em cinco etapas

Um agente de autocorreção executa o mesmo loop todas as vezes, com dois portões:

Recepção: coletar o relatório, a requisição que falha e a resposta recebida.
Reproduzir: escrever um teste que falha pelo motivo relatado. Sem teste que falha, sem correção.
Corrigir: aplicar a correção no código em um branch ou worktree isolado.
Reexecutar: o novo teste deve passar, e a suíte existente também.
Entregar: abrir um pull request com as evidências ou ficar em silêncio.

Etapa 1: Receber o relatório de bug

Seu agente não consegue reproduzir “o checkout quebrou de novo”. Dê à recepção um formato fixo:

Campo	Exemplo	Por que importa
Endpoint	`POST /orders`	Qual handler ler
Requisição	Corpo com `"coupon": null`	A entrada exata que quebrou o sistema
Resposta real	`500`, `{"error":"internal"}`	O que o teste deve ver falhar
Resposta esperada	`201` com um `id` de pedido	O que o teste verifica
Ambiente	staging	Onde a reprodução é executada

Se faltarem campos, o agente pergunta uma vez ou extrai a requisição dos logs. Corpos de erro que seguem os RFC 9457 problem details ajudam, porque o tipo de erro chega em um formato previsível.

Etapa 2: Reproduzir o bug como um teste de API que falha

Esta é a porta de entrada. O agente transforma o registro de recepção em um caso de teste com duas asserções — o código de status esperado e um campo que a resposta deve conter — e o executa no ambiente real. Três resultados são possíveis:

Falha pelo motivo relatado. Você tem uma reprodução. Prossiga.
Passa. O bug não é reproduzível como descrito. Registre nos logs e pare.
Falha por outro motivo (erro de autenticação, dados ausentes, timeout). Essa é uma reprodução quebrada, não um bug confirmado. Pare.

Somente o primeiro desbloqueia uma correção. É isso que “em silêncio” significa na prática: os outros dois geram uma entrada de log para quem revisa a fila, não uma mensagem no chat do usuário.

Escreva a reprodução como um teste de API, não um teste de unidade: o agente acessa a mesma interface que o usuário acessou, então não reproduz um bug diferente por acidente.

Etapa 3: Corrigir o código em um branch isolado

Quando a reprodução está vermelha, o worker recebe sua própria cópia do código. Um git worktree é a opção mais leve: um segundo diretório de trabalho em um novo branch, de modo que as edições do agente nunca toquem no seu checkout. Execute o serviço a partir dele e aponte o ambiente de teste para lá.

Mantenha duas restrições rigorosas. A correção deve ser pequena: defina um limite, como 3 arquivos ou 50 linhas alteradas, e trate qualquer coisa maior como um relatório para um humano. E ela deve mirar a reprodução: sem refatorações, renomeações ou arrumações, porque cada mudança extra é algo que seu revisor precisa verificar.

Etapa 4: Reexecutar a reprodução e a suíte completa

O segundo portão tem duas partes. Primeiro, o agente reexecuta o mesmo caso de teste da etapa 2, sem alterações, e ele deve passar. Se o agente editou as asserções para conseguir isso, a correção falha; seu pipeline detecta isso comparando (diff) o arquivo de teste antes e depois.

Segundo, a suíte existente deve continuar verde. Uma correção que deixa um teste verde e três vermelhos volta para a etapa 3. Limite o loop no tempo, por exemplo 3 tentativas ou 20 minutos, depois pare e registre o que foi tentado. É aqui que o watchdog prova seu valor: ele pode eliminar um worker que fica editando a mesma linha ou que se desvia para arquivos que a reprodução nunca tocou.

Etapa 5: Entregar apenas uma correção confirmada e simples

Quando ambos os portões estão verdes, o agente abre um pull request com evidências, não com histórias: o relatório, a execução que falhou, o diff e a execução que passou com os resultados da suíte. Um humano revisa e faz o merge. Branches protegidos garantem que o token do agente possa fazer push de um branch, mas nunca fazer merge em main. Se qualquer portão falhar, o reportador não ouve nada; o agente escreve uma linha de log e segue em frente.

Salvaguardas para um agente de IA que se autocorrige

Configure estas barreiras antes da primeira execução sem supervisão:

Salvaguarda	Configuração	O que previne
Escopo	Máximo de arquivos e linhas por correção	Reescritas disfarçadas de correções
Limite de tempo	Máximo de tentativas e minutos por bug	Loops fora de controle queimando tokens
Credenciais	Apenas staging, sem chaves de produção	Uma reprodução que cria pedidos reais
Direitos de merge	Push de branches, nunca merge	Código não revisado chegando a `main`
Integridade do teste	Comparar o arquivo de teste antes e depois	Asserções editadas para passar
Silêncio	Nenhuma mensagem ao usuário em caso de falha	Ruído e afirmações meio confirmadas

As credenciais são o mais importante: uma reprodução acessa a API de verdade, então use staging ou dados locais pré-carregados.

Deixe seu agente de codificação construir a reprodução com o Apidog CLI

A etapa 2 é o coração do pipeline, e é para isso que o Apidog CLI foi construído. Seu agente de codificação (Claude Code, Codex, Cursor ou OpenCode) escreve o caso de teste como JSON, cria-o no seu projeto Apidog e o executa a partir do terminal. Você escreve um único prompt.

Configure uma vez:

npm install -g apidog-cli@latest
apidog auth login --with-token <YOUR_TOKEN>
npx -y skills add https://apidog.com   # pick your agent when prompted

Em seguida, entregue ao seu agente o relatório de bug e este [REDACTED PROMPT]
Here is a bug report for POST /orders in Apidog project .
Turn it into an Apidog test case that fails today: assert status 201
and that $.id exists. Run it against staging and confirm it fails for
the reported reason. If it does, fix the handler on a new worktree
branch until the same test passes, run the endpoint's other cases, and
open a PR with both JSON reports. If it doesn't reproduce, stop and log why.


O agente não constrói o payload de memória. Ele lê o schema, encontra uma categoria, valida o arquivo e só então cria o caso:

bash
apidog cli-schema get test-case-create
apidog test-case category --project
apidog cli-schema validate test-case-create --file repro-orders.json
apidog test-case create --project --file repro-orders.json


O arquivo que ele escreve fica assim (os IDs vêm do seu projeto):

json
{
"name": "Repro: POST /orders with null coupon returns 500",
"apiDetailId": 123456,
"categoryId": 1,
"method": "post",
"path": "/orders",
"parameters": {},
"commonParameters": {},
"requestBody": {
"type": "application/json",
"data": "{\"items\":[{\"sku\":\"A-100\",\"qty\":1}],\"coupon\":null}"
},
"postProcessors": [
{ "type": "assertion", "defaultEnable": true, "enable": true,
"data": { "name": "status is 201", "subject": "httpCode", "comparison": "equal", "path": "", "value": "201" } },
{ "type": "assertion", "defaultEnable": true, "enable": true,
"data": { "name": "order id exists", "subject": "responseJson", "comparison": "exists", "path": "$.id" } }
]
}


Agora, a execução vermelha que prova o bug:

bash
apidog run --test-case --project -e -r cli,json --out-file repro-before


O reporter do CLI mostra a asserção de status falhando com um 500, e `repro-before.json` é salvo em `apidog-reports/`. Após a correção, o agente executa o comando idêntico com `--out-file repro-after` e ambas as asserções passam. Esses dois arquivos são as evidências no pull request. Para a etapa 4, ele executa todos os casos do endpoint para que a correção não quebre silenciosamente um vizinho:

bash
apidog test-case run --project --endpoint -e -r cli,json




Adicione `--upload-report` para exibir a execução no app do Apidog. Depois do merge, o caso de reprodução permanece no seu projeto como um teste de regressão, e o mesmo `apidog run` com `-r junit` se integra ao CI, como mostrado em [executando o Apidog CLI em um pipeline de CI/CD](https://apidog.com/pt/blog/apidog-cli-ci-cd-pipeline?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation). Para mais configurações, veja o [fluxo de trabalho do agente com Apidog CLI](https://apidog.com/pt/blog/apidog-cli-agent-workflow?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation) e [Apidog CLI no Claude Code](https://apidog.com/pt/blog/apidog-cli-in-claude-code?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation). O Apidog Free cobre até 4 usuários, então você pode experimentar o loop completo sem um plano pago.

## FAQ

### Um agente de IA realmente pode corrigir bugs sem um humano?

Ele pode reproduzir, corrigir e comprovar muitos bugs simples sozinho, mas não deve fazer o merge deles. Mantenha um humano no merge e deixe a proteção de branches garantir isso.

### E se o agente não conseguir reproduzir o bug?

Ele para e registra nos logs o que tentou. Um bug que ele não consegue reproduzir é uma correção que ele não pode confirmar, então qualquer patch seria um palpite. Um humano então adiciona detalhes ao relatório ou o encerra.

### Como impedir o agente de editar o teste para fazê-lo passar?

Salve uma cópia ou um hash do caso de teste quando ele falhar pela primeira vez e compare antes de aceitar a correção. Mantenha o arquivo de teste fora dos caminhos que o worker pode editar.

### Preciso do DeepSeek Harness para construir isso?

Não. O ensaio descreve um design, e seu plugin de protótipo não é um produto oficial da DeepSeek. Qualquer agente de codificação que execute comandos shell funciona, incluindo o Claude Code no [GitHub Actions](https://apidog.com/pt/blog/claude-code-github-actions?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation). Veja [o que é o DeepSeek Harness](https://apidog.com/pt/blog/what-is-deepseek-harness?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation) se quiser experimentá-lo lá.

Como estender um vídeo com o Gemini Omni 1.2 Flash

Lucas — Fri, 06 Nov 2026 03:38:18 +0000

Como estender um vídeo com o Gemini Omni 1.2 Flash

Resposta rápida: Para estender um vídeo com o Gemini Omni 1.2 Flash, envie seu clipe e um prompt curto de continuação para a API Interactions. Cada turno adiciona de 3 a 10 segundos e retorna o clipe mais longo. Na Gemini API, o limite é de 30 segundos no total. A Agent Platform do Google Cloud chega a 40, mas somente se você planejar cada etapa para que ela não corte o início do seu vídeo.

Experimente o Apidog hoje

Para dicas de escrita de prompts, consulte nosso guia de extensão de cena do Omni 1.1. Este guia cobre as novidades: as requisições, os cálculos do encadeamento e o custo de um clipe de 40 segundos.

Como funciona a extensão de vídeo do Gemini Omni 1.2 Flash

A extensão de vídeo gera uma continuação no final de um clipe. O modelo lê até os últimos 10 segundos da sua entrada como contexto, gera de 3 a 10 segundos novos e os une ao clipe. Ele apenas anexa ao final: não é possível adicionar conteúdo no início nem estender o meio do vídeo.

O Google documenta limites diferentes dependendo de onde você chama o modelo:

	Gemini API	Agent Platform (Google Cloud)
Autenticação	Chave de API	Projeto e token de acesso
Duração total	30 segundos	40 segundos
Duração da entrada	Sem limite separado especificado	Qualquer duração
Imagens de referência	Até 6 no Omni	Até 2 por extensão
Modo de extensão	Prompt primeiro, `task` como fallback	`task: "extend"` em todos os exemplos
Seed e labels	Não aparecem na documentação do Omni	`generation_config.seed`, `labels`
Resultados armazenados	55 dias no plano pago	Até 7 dias

Fontes: a documentação do Omni da Gemini API e a documentação de extensão da Agent Platform.

Na Agent Platform, o modelo lê até os últimos 10 segundos e concatena o novo segmento aos últimos 30 segundos da entrada. O exemplo do Google estende uma entrada de 60 segundos em 10 segundos e retorna 40 segundos, ou seja, os primeiros 30 segundos são descartados.

Você não precisa montar nada manualmente, já que a saída inclui as filmagens anteriores. O Google edita alguns quadros finais da sua entrada para suavizar a transição.

O que mudou na extensão na versão 1.2

Clipes iniciais de 15 segundos. Na 1.1, o limite era 10. Cada turno de extensão continua limitado a 10 segundos.
Imagens de referência, seed e labels nas requisições de extensão da Agent Platform.
Nova sintaxe de prompt. O Google descontinuou tags como <IMAGE_REF_0>, usadas em guias mais antigos. Descreva cada imagem em linguagem natural.
Novo tipo de entrada. Os exemplos atuais usam "type": "video", e não o tipo document dos exemplos da 1.1.

Como estender um vídeo passo a passo na Gemini API

Gere um clipe ou faça upload de um pela API Files. Os arquivos enviados são excluídos após 48 horas.
Descreva apenas o que acontece em seguida.
Defina duration entre "3s" e "10s" (padrão: 10).
Salve o ID da interação para o próximo turno.

from google import genai

client = genai.Client()

first = client.interactions.create(
    model="gemini-omni-1.2-flash",
    input="A courier in a yellow jacket cycles through a rainy night market.",
    response_format={"type": "video", "duration": "15s"},
)

second = client.interactions.create(
    model="gemini-omni-1.2-flash",
    previous_interaction_id=first.id,
    input="The courier brakes at a red door. Keep the same yellow jacket.",
    response_format={"type": "video", "duration": "10s", "delivery": "uri"},
)

Para estender suas próprias filmagens, substitua previous_interaction_id por um array de entrada com {"type": "video", "uri": video_file.uri} e um item de texto.

Deixe task de lado no início. Segundo o Google, ela adiciona restrições rígidas, então defina "task": "extend" em video_config apenas como fallback.
Use delivery: "uri" acima de 4MB. Guarde o URI da resposta de criação. Um GET posterior retorna base64 inline mesmo para requisições com URI.
Mantenha store ativado. Com store: false, não é possível continuar a partir daquele ID de interação.

Os uploads têm duas restrições adicionais: não é possível adicionar diálogo onde alguém esteja falando, e não é possível estender a partir do EEE (Espaço Econômico Europeu), da Suíça ou do Reino Unido. A extensão multi-turno de vídeo gerado evita ambas.

Passo a passo da requisição na Agent Platform

Use esta rota para chegar a 40 segundos ou para uma fila de jobs. A geração pode levar mais de um minuto, então envie este corpo via POST para https://aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/global/interactions com background ativado:

{
  "model": "gemini-omni-1.2-flash",
  "background": true,
  "input": [
    { "type": "text", "text": "The courier opens the red door and steps inside." },
    { "type": "video", "uri": "gs://my-bucket/hop-1.mp4", "mime_type": "video/mp4" }
  ],
  "response_format": [
    {
      "type": "video",
      "delivery": "uri",
      "gcs_uri": "gs://my-bucket/out/",
      "aspect_ratio": "16:9",
      "duration": "5s"
    }
  ],
  "generation_config": {
    "seed": 4242,
    "video_config": { "task": "extend" }
  },
  "labels": { "campaign": "courier", "hop": "2" }
}

A chamada retorna um ID de interação com status in_progress. Consulte com polling usando GET .../locations/global/interactions/INTERACTION_ID. Quando a execução terminar, leia o URI gs:// na etapa model_output dentro de steps. Esse URI se torna a entrada para o próximo salto.

Também existem os modos stateless (store: false), stateful (store: true) e streaming. Os resultados armazenados e assíncronos ficam disponíveis por até 7 dias, então copie tudo o que precisar.

[VERIFY] Não executado: nenhum projeto do Google Cloud estava disponível. O corpo de exemplo do Google não inclui nem seed nem labels, portanto confirme onde inseri-los.

Encadeando até o limite de 40 segundos

Um salto só preserva todas as suas filmagens se a entrada dele tiver 30 segundos ou menos. Para chegar a 40 sem perder nada, alcance exatamente 30 primeiro.

Salto	`duration` planejada	Saída planejada	`duration` sem planejamento	Saída sem planejamento
Início	15s	15s	15s	15s
1	10s	25s	10s	25s
2	5s	30s	10s	35s
3	10s	40s	10s	40s, com os primeiros 5s descartados

A cadeia sem planejamento ganha 5 segundos extras e depois joga fora o início do seu vídeo. A duração do clipe não vai alertá-lo, porque as duas cadeias retornam 40 segundos.

Um início de 15 segundos não economiza chamadas para chegar a 40: começar com 10 também exige três extensões. Ele ajuda em outros casos, já que 25 segundos exigem uma extensão em vez de duas, e 35 exigem duas em vez de três.

Na Gemini API, pare depois do salto 2. O Google não informa o que acontece com uma requisição acima de 30 segundos.

Mantenha os personagens consistentes com imagens de referência e seed

Um personagem que saiu de quadro antes dos últimos 10 segundos fica invisível para o modelo, mesmo que esses quadros permaneçam no clipe. A solução do Google: mencione o personagem novamente ou passe uma imagem de referência no mesmo array input:

{ "type": "image", "uri": "gs://my-bucket/courier.png", "mime_type": "image/png" },
{ "type": "text", "text": "The courier from the reference image walks back into frame." }

Reutilize a mesma imagem em todos os saltos que precisarem desse personagem.
Escolha com cuidado na Agent Platform. Duas imagens por extensão cobrem apenas o que tem maior chance de sofrer variações.
Não envie vídeos de referência. O Google os suporta apenas para geração nova, não para extensão.
Informe os tempos com base no novo segmento. 0s no seu prompt significa o início da parte estendida, não o início do clipe.

Defina generation_config.seed para obter resultados reproduzíveis. Isso ajuda principalmente na depuração: execute o mesmo salto novamente com a mesma seed para verificar se uma mudança veio do seu prompt. O Google não garante que uma seed mantenha um personagem consistente entre prompts diferentes, então conte com as referências para isso. Use labels para acompanhar o faturamento por salto.

Quanto custa um clipe de 40 segundos

A página de preços do Google cobra a saída de vídeo do Omni 1.2 a US$ 12,00 por milhão de tokens. Não há informação sobre se uma extensão é cobrada apenas pelos segundos novos ou por todos os segundos retornados. A cadeia planejada gera 40 segundos, mas retorna 15, 25, 30 e 40, o que soma 110.

Resolução	Por segundo	Se apenas os segundos novos forem cobrados	Se todos os segundos retornados forem cobrados
360p	US$ 0,023	US$ 0,93	US$ 2,55
720p	Cerca de US$ 0,07	US$ 2,78	US$ 7,65
1080p (com upscale)	US$ 0,104	US$ 4,17	US$ 11,47
4K (com upscale)	US$ 0,209	US$ 8,34	US$ 22,94

Essas são as tarifas da Gemini API, calculadas a partir dos tokens por segundo do Google. Tokens de entrada (US$ 1,50 por milhão) e tokens de raciocínio (US$ 9,00 por milhão) são cobrados à parte.

Até que você verifique, faça o orçamento com base na coluna da direita. Para manter a conta baixa:

Faça os rascunhos em 360p e valide toda a cadeia antes de pagar pelo 720p.
Escolha a resolução antes de encadear. A página do modelo na Agent Platform limita a entrada de upscale a 15 segundos, então um clipe finalizado de 40 segundos não cabe em uma única passagem.
Inclua regenerações de cenas difíceis no orçamento. O anúncio do Google cita ações esportivas rápidas, mudanças velozes de roteiro e física complexa como áreas ainda em aprimoramento.

As requisições para gemini-omni-1.1-flash são direcionadas à versão 1.2 a partir de 3 de dezembro de 2026 e cobradas nas tarifas da 1.2.

Deixe seu agente de codificação testar o fluxo assíncrono com a Apidog CLI

Uma cadeia assíncrona falha em silêncio: um polling que nunca termina, uma execução que termina como failed, um formato de resposta que muda. Deixe seu agente de codificação criar esse teste com a Apidog CLI e executá-lo para você.

npm install -g apidog-cli@latest
apidog auth login --with-token <YOUR_TOKEN>
apidog skill install

Depois, dê ao Claude Code, Codex ou Cursor um único [REDACTED PROMPT]
In Apidog project , create endpoints for POST and GET on the Omni
interactions URL. Build a test scenario named omni-extend-async: start a
3-second 360p extension with background set to true, save the interaction
ID, then loop with a 10-second delay on GET until status leaves in_progress.
Assert status is completed and a model_output step holds a video/mp4 item
with a uri or data. Run it and summarize any failures.


O agente valida seu payload e, em seguida, cria e executa o cenário:

bash
apidog cli-schema get test-scenario-update
apidog test-scenario create --project --name "omni-extend-async" --folder-id --priority 1
apidog test-scenario import-steps --project --source endpoint --ids ,
apidog cli-schema validate test-scenario-update --file scenario.json
apidog test-scenario update --project --file scenario.json
apidog run -t --project -e --timeout-request 300000 -r cli,junit --out-dir ./reports




Cada execução gera um clipe real e é cobrada, então rode à noite, e não a cada commit. Um salto de 3 segundos em 360p custa cerca de US$ 0,07 se apenas os segundos novos forem cobrados. A mesma linha se encaixa em um pipeline, como mostra nosso [guia de CI/CD da Apidog CLI](https://apidog.com/pt/blog/apidog-cli-ci-cd-pipeline?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation), e o [guia de configuração do Claude Code](https://apidog.com/pt/blog/apidog-cli-in-claude-code?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation) cobre o lado do agente. O Apidog Free atende até 4 usuários.

## FAQ

**Quanto tempo pode durar um vídeo do Gemini Omni 1.2 Flash?** Uma única geração produz de 3 a 15 segundos. Com extensão, a documentação da Gemini API indica 30 segundos no total, e a da Agent Platform, 40.

**Por que o início do meu vídeo estendido desapareceu?** Na Agent Platform, apenas os últimos 30 segundos da entrada são mantidos. Qualquer entrada com mais de 30 segundos perde o começo. Planeje seus saltos para que o último comece exatamente a partir de 30 segundos.

**Posso estender um vídeo que eu mesmo gravei?** Sim, fora do EEE, da Suíça e do Reino Unido. Faça o upload pela API Files ou aponte para o Cloud Storage na Agent Platform. Não é possível adicionar diálogo a um clipe enviado onde alguém esteja falando.

**Posso estender um clipe de graça?** Não pela API. O Google lista o plano gratuito como "Não disponível" para o Omni 1.2 e 1.1, então até um teste é cobrado. Uma extensão de 3 segundos em 360p é a mais barata que você pode executar.

O que é o GPT-6 Cyber? Acesso, preços e como testar a API

Lucas — Fri, 06 Nov 2026 02:43:40 +0000

O que é o GPT-6 Cyber? Acesso, preços e como testar a API

O GPT-6 Cyber é o modelo de segurança cibernética da OpenAI para pesquisa autorizada de vulnerabilidades, desenvolvimento de exploits e testes de penetração, anunciado em 5 de novembro de 2026. Ele custa US$ 20 por milhão de tokens de entrada e US$ 100 por milhão de tokens de saída. Você o chama como gpt-6-cyber pela API Responses, mas apenas com acesso Daybreak Red mais uma aprovação separada para este modelo.

Experimente o Apidog hoje

Essa é a principal diferença em relação ao último lançamento. Quando cobrimos o GPT-5.6 Cyber em agosto, não havia preço público nem formato de requisição público. Agora a OpenAI documenta o ID do modelo, o preço, a requisição e os erros. Porém, uma chave de API comum ainda não dá acesso a você.

Este guia aborda o que é o modelo, quem pode usá-lo, quanto custa e como testar a integração. Um esclarecimento: não temos acesso Daybreak Red, então nada abaixo foi executado contra o gpt-6-cyber. A requisição e os códigos de erro vêm do guia da API Daybreak da OpenAI, verificado em 6 de novembro de 2026.

O que é o GPT-6 Cyber?

O GPT-6 Cyber é uma variante do GPT-6 Astra especializada em cibersegurança, criada para trabalhos de segurança autorizados, como encontrar vulnerabilidades, desenvolver exploits e realizar pentests web. A OpenAI fez o pós-treinamento dele com aprendizado por reforço para que recuse menos tarefas de segurança autorizadas e permaneça dentro do escopo definido pelo pesquisador.

Três fatos do system card do GPT-6 Cyber ajudam você a situá-lo:

É um especialista. A OpenAI diz que ele não supera o Astra em programação geral: 82,95% no ExpertSWE contra os 83,24% do Astra.
Ele é classificado como Crítico. Sob o Preparedness Framework da OpenAI, ele recebe a classificação Crítico em Cibersegurança, a mesma do GPT-6 Astra. O GPT-5.6 Cyber foi classificado como Alto.
Ele completa o que o Astra recusa. No RemoteExploitBench, o Astra com Daybreak Blue recusou todas as tarefas, enquanto o GPT-6 Cyber completou 95%.

Os resultados de destaque da OpenAI vêm de alvos reais. Seus pesquisadores usaram o modelo para desenvolver 948 exploits de escalonamento de privilégios no Linux e encontrar 81 vulnerabilidades de alta gravidade no Firefox, que a Mozilla já começou a corrigir. Esses são os números divulgados pela OpenAI no anúncio do GPT-6 Cyber, não resultados independentes.

Quem pode acessar o GPT-6 Cyber?

Hoje, apenas organizações aprovadas podem usá-lo. A OpenAI diz que o GPT-6 Cyber está inicialmente disponível pela API e pelo Codex para um grupo seleto de clientes Daybreak Red, e que o acesso será ampliado para todos os clientes Red em breve. Nenhuma data foi informada.

Nível de acesso	Quem pode obter	O que você recebe	GPT-6 Cyber?
Standard	Qualquer conta de API	Modelos principais, salvaguardas padrão	Não
Daybreak Blue	Pessoas físicas e organizações verificadas	Menos recusas em modelos como GPT-6 Sol e GPT-6 Luna	Não
Daybreak Red	Organizações empresariais e corporativas aprovadas	GPT-5.6 Cyber, além de menos recusas em modelos principais, incluindo o Astra	Não por si só
Red + aprovação de modelo	Organizações Red aprovadas para este modelo	GPT-6 Cyber e GPT-5.6 Cyber	Sim

A visão geral do Daybreak detalha quatro limitações que vale a pena ler antes de solicitar acesso:

Pessoas físicas não podem solicitar o Red. Elas podem solicitar o Blue, que exige um plano pago, verificação de identidade e uma chave de segurança FIDO2 física.
Dinheiro não compra acesso. Um contrato ou uma compra não garante a aprovação.
A aprovação não ativa nada por si só. Um proprietário ainda precisa habilitar o Daybreak para um projeto, e habilitar o Red não concede o GPT-6 Cyber.
Uso voltado a clientes está excluído. O Daybreak não serve para tráfego de produtos downstream nem para terceiros, a menos que a OpenAI tenha aprovado uma configuração específica. Parceiros passam por um programa separado.

Você pode solicitar acesso pela página do Daybreak. Para saber mais sobre os níveis, consulte nosso guia Daybreak Blue vs Red. Empresas de serviços públicos e projetos de código aberto também podem registrar interesse no Daybreak for Frontline Defenders, programa de acesso subsidiado de US$ 1 bilhão da OpenAI.

Preços e especificações do GPT-6 Cyber

A OpenAI lista o GPT-6 Cyber por exatamente o dobro do preço do GPT-6 Astra, de acordo com sua página de preços e página do modelo.

Por 1M de tokens	GPT-6 Cyber	GPT-6 Astra	GPT-5.6 Cyber
Entrada	US$ 20,00	US$ 10,00	US$ 12,50
Entrada em cache	US$ 2,00	US$ 1,00	US$ 1,25
Saída	US$ 100,00	US$ 50,00	US$ 75,00
Gravação de cache de 30 minutos	US$ 25,00	US$ 12,50	US$ 15,625
Gravação de cache de 12 horas	US$ 50,00	US$ 25,00	US$ 31,25

Esses são os valores para contexto curto. A página de preços não mostra um valor de contexto longo para o GPT-6 Cyber, portanto confirme com sua equipe de contas antes de planejar com base em prompts muito grandes.

Uma chamada com 50.000 tokens de entrada e 10.000 tokens de saída custa US$ 2,00 no GPT-6 Cyber e US$ 1,00 no Astra. Execuções de agentes repetem chamadas, então o cache importa: a entrada em cache custa um décimo do valor cheio.

As especificações na página do modelo:

Janela de contexto: 1.050.000 tokens
Saída máxima: 128.000 tokens
Entrada e saída: texto e imagem de entrada, texto de saída
Recursos: streaming, function calling e saídas estruturadas. Sem fine-tuning.
Ferramentas: pesquisa na web, pesquisa de arquivos, interpretador de código, shell hospedado, apply patch, skills, computer use, MCP e pesquisa de ferramentas
Limites de taxa: 5.000 requisições por minuto e 1 milhão de tokens por minuto no nível Build, a menos que sua organização tenha limites personalizados

Benchmarks do GPT-6 Cyber vs. GPT-5.6 Cyber e Astra

O ganho do GPT-6 Cyber sobre o GPT-5.6 Cyber é grande, enquanto sua vantagem sobre o Astra é menor e não se mantém em todos os testes. Todas essas pontuações vêm do anúncio e do system card da OpenAI.

Avaliação	GPT-6 Cyber	GPT-6 Astra	GPT-5.6 Cyber
ExploitGym	48,45%	42,43%	32,1%
ExploitGym Hardened	36,94%	29,69%	Não informado
SRE-Bench (engenharia reversa)	92,84%	87,98%	Não informado
Recall de pentest web	40,3%	32,0%	Não informado
Honeypot explorado, sem prompt de segurança	0,07%	0%	5,51%

A linha do honeypot importa se você executa agentes. A OpenAI coloca um serviço fácil de atacar e fora do escopo ao lado de uma tarefa difícil. O GPT-6 Cyber cruzou essa linha em 0,07% das execuções avaliadas e em nenhuma quando instruções de segurança de implantação foram adicionadas.

Onde o GPT-6 Cyber é mais fraco

O system card também mostra pontos em que ele fica atrás do Astra. Eles importam mais para o seu plano de testes do que as pontuações de destaque:

Relato de bloqueios: 20,29% das respostas finais avaliadas foram sinalizadas, contra 11,66% do Astra. A OpenAI diz que, na maioria das execuções sinalizadas, o bloqueio foi comunicado antes, mas omitido do resumo.
Parar diante de avisos: ele parou 73,00% das vezes em que parar era o correto, contra 78,38% do Astra.
FrontierCyber: no teste externo da Irregular, ele marcou 90 de 288, contra 96 do Astra. Nenhum dos modelos resolveu qualquer um dos 15 desafios mais difíceis.

A lição prática é simples: não aceite o resumo final do agente como prova. Verifique as evidências, mantenha um humano acompanhando execuções de alto risco e siga a recomendação da OpenAI de executar em ambientes isolados, com limites explícitos para alvos e credenciais.

Como chamar o GPT-6 Cyber pela API

Use a API Responses com model definido como gpt-6-cyber e access_programs.cyber definido como daybreak_red. Selecionar o Red não troca seu modelo nem concede acesso a um, então você precisa dos dois campos e da configuração abaixo.

Confirme com sua equipe de contas que sua organização tem o Daybreak Red e a aprovação para o GPT-6 Cyber.
Exija SSO na organização da API e aplique MFA por meio do seu provedor de identidade.
Peça a um proprietário da organização para habilitar o Daybreak Red em um projeto que não seja o padrão. Projetos padrão não podem habilitá-lo, e as alterações podem levar cerca de 15 minutos.
Crie uma chave de API nesse projeto.
Adicione seus IPs públicos de egress à allowlist de IPs.
Se o projeto usa Zero Data Retention, configure o Private Safety Processing.

Em seguida, envie a requisição documentada pela OpenAI:

curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-cyber",
    "access_programs": {"cyber": "daybreak_red"},
    "safety_identifier": "user_a17f",
    "input": "Suggest a regression test for a path traversal fix."
  }'

Substitua safety_identifier por um ID estável e pseudônimo da pessoa que faz a requisição. Na resposta, verifique model e access_programs.cyber para confirmar o que de fato atendeu à chamada.

O guia do Daybreak documenta três erros de acesso:

Erro	O que significa	Como resolver
`400 invalid_access_program`	Valor de programa incorreto para este modelo	Use o valor indicado no erro
`400 unsupported_access_program`	O modelo não suporta o Daybreak	Troque de modelo ou envie `standard`
`403 access_program_not_enabled`	O projeto ou a organização da chave não possui o programa	Verifique o projeto e, depois, solicite acesso

A validação de campos também falha: access_programs e cyber são opcionais, mas nenhum dos dois aceita null. Além disso, um erro de acesso não é o mesmo que uma recusa. As salvaguardas continuam valendo após a aprovação, então um prompt recusado não prova que sua configuração está errada.

Deixe seu agente de programação testá-lo com a Apidog CLI

Um modelo com acesso restrito tem uma configuração estreita e um modo de falha caro, então o ideal é que seu agente fique encarregado das verificações. A Apidog CLI permite que ele as escreva uma única vez e as execute de novo a cada rotação de chave ou alteração de allowlist. O Apidog Free cobre até 4 usuários.

npm install -g apidog-cli@latest
apidog auth login --with-token <YOUR_TOKEN>
apidog skill install

Depois, dê ao seu agente um único prompt. Ele funciona com ou sem acesso Daybreak, porque o ramo de mock não precisa de chave da OpenAI:

In Apidog project <id>, add POST /v1/responses from OpenAI's Daybreak guide.
Create mock expectations for a success response and for 400
invalid_access_program and 403 access_program_not_enabled. Create a test
scenario that checks our client handles each one. If OPENAI_API_KEY is set,
add one preflight request with the documented path traversal prompt and
assert status 200, model is gpt-6-cyber, and access_programs.cyber is
daybreak_red. Never send exploit prompts or real targets. Run it against
the <env> environment and summarize failures.

O agente lê cada schema, valida o payload e executa o cenário:

apidog cli-schema get endpoint-create
apidog endpoint create --project <id> --file endpoint.json
apidog cli-schema get mock-create
apidog mock create --project <id> --file mock-403.json
apidog cli-schema validate test-scenario-create --file scenario.json
apidog test-scenario create --project <id> --file scenario.json
apidog run -t <scenarioId> --project <id> -e <envId> -r cli,json

Mantenha a verificação em ambiente real restrita a essa única requisição pequena, já que cada execução é cobrada a preço cheio, e execute-a a partir de um IP na allowlist. Os corpos dos mocks devem usar apenas campos documentados pela OpenAI, porque não conseguimos capturar uma resposta real.

A mesma linha apidog run com -r junit entra direto em um pipeline, como mostrado no nosso guia de CI/CD com a Apidog CLI. Para configurar o agente, veja Apidog CLI no Codex.

FAQ

O GPT-6 Cyber está disponível para todos? Não. Ele é limitado a organizações Daybreak Red com aprovação separada para o GPT-6 Cyber. A OpenAI diz que o acesso será ampliado para todos os clientes Red em breve, mas não deu uma data nem anunciou disponibilidade geral.

Quanto custa o GPT-6 Cyber? US$ 20 por milhão de tokens de entrada, US$ 2 por milhão de tokens de entrada em cache e US$ 100 por milhão de tokens de saída, nos preços para contexto curto. A aprovação continua necessária, e apenas uma compra não garante o acesso.

Qual é o ID do modelo do GPT-6 Cyber? Use gpt-6-cyber no campo model, com access_programs.cyber definido como daybreak_red.

Pessoas físicas podem usar o GPT-6 Cyber? Não por meio de inscrição. Pessoas físicas podem solicitar apenas o Daybreak Blue, e o Blue não dá acesso a modelos especializados em cyber. A OpenAI observa que alguns indivíduos têm acesso como exceção.

O GPT-6 Cyber é melhor que o GPT-6 Astra? Para trabalho ofensivo de segurança autorizado, em geral, sim. Ele supera o Astra no ExploitGym e no SRE-Bench e recusa muito menos. Para programação geral, a OpenAI não relata ganho, e ele custa o dobro.

Posso usar o GPT-6 Cyber no Codex? Sim, depois que sua organização for aprovada. Faça login com seu workspace aprovado ou use uma chave de API de um projeto com o Daybreak Red habilitado. A OpenAI recomenda o sandboxing e o Auto-Review do Codex para este modelo.

Subagentes do Claude Code agora consomem menos do seu limite de uso

Lucas — Fri, 06 Nov 2026 02:38:14 +0000

Subagentes do Claude Code agora consomem menos do seu limite de uso

Os subagentes do Claude Code agora consomem menos do seu limite de uso. A Anthropic mudou a linha de status dos subagentes em segundo plano: em vez de reler toda a conversa, o Haiku 5.5 agora trabalha a partir de anotações curtas. Cada atualização custa cerca de 99% menos, e sessões com subagentes em segundo plano usaram cerca de 5% menos do limite. Atualize para a v2.1.316 ou posterior para obter o recurso.

Experimente o Apidog hoje

Essa é a história completa em quatro frases. O restante deste post aborda quem recebe a mudança, o que as duas porcentagens significam, o que permanece desconhecido e quais configurações reduzem ainda mais o uso dos subagentes.

O que mudou nos subagentes do Claude Code

Um subagente em segundo plano é um auxiliar que roda junto com a sua sessão principal enquanto você continua trabalhando. No terminal, ele exibe uma linha de status curta para você acompanhar o que está fazendo, e essa linha é atualizada a cada 30 segundos.

A Anthropic anunciou a mudança no X em 5 de novembro de 2026:

Antes: cada atualização de 30 segundos relia toda a conversa do subagente.
Agora: o Haiku 5.5 escreve a atualização a partir de anotações curtas.
Sem alteração: o subagente mantém o próprio modelo. Se ele roda no Opus 5.5 ou no Sonnet 5.5, continua assim. Apenas a linha de status migrou para o Haiku 5.5.

Você não precisa alterar nenhuma configuração nem abrir mão da qualidade do trabalho em si. A saída do subagente vem do mesmo modelo de antes.

Por que a linha de status de um subagente era cara

A linha de status era cara porque um resumo de uma linha pagava a leitura completa de uma conversa longa. A saída era minúscula, mas a entrada não — e a tarefa se repetia a cada 30 segundos durante todo o tempo em que o subagente rodava.

A aritmética mostra a rapidez com que isso se acumula. Com uma atualização a cada 30 segundos, um subagente rodando por uma hora gera 120 atualizações. Três rodando por uma hora geram 360.

O comprimento da conversa também pesa. A documentação de custos do Claude Code diz que o custo em tokens escala com o tamanho do contexto, e a conversa de um subagente cresce à medida que ele lê arquivos e executa ferramentas. Ou seja, o design antigo provavelmente cobrava mais justamente quando um subagente de longa duração acumulava mais contexto. Essa é a nossa leitura da documentação, já que a Anthropic não publicou uma curva de custos para isso.

Não confunda isso com a linha de status personalizada que você configura com o /statusline. A documentação da linha de status diz que essa roda localmente e não consome tokens da API. A mudança aqui se refere à linha de status que o Claude Code gera para cada subagente em execução.

Os números: 99% por atualização, cerca de 5% por sessão

Os dois números medem coisas diferentes, e apenas um deles descreve o seu limite.

Número	O que mede	O que não é
Cerca de 99% menos	O custo de uma atualização de status	Uma economia na sua fatura ou no seu limite
Cerca de 5% menos	O limite usado por sessões com subagentes em segundo plano	Uma economia em sessões sem eles
Cerca de 6% a mais	Prompts que você obtém com o mesmo limite, segundo a Anthropic	Um aumento do limite em si

Se você for lembrar de um único número, que seja o 5%. Um corte de 99% em algo que era uma pequena parte da sessão resulta em uma economia pequena na sessão como um todo. Os subagentes continuam fazendo o trabalho real com o próprio modelo, e é esse trabalho que consome a maior parte do uso.

A Anthropic não disse quanto do limite as atualizações de status consumiam antes. Os dois números, juntos, sugerem cerca de um vigésimo dessas sessões, mas isso é uma inferência a partir de valores arredondados, não um dado publicado.

A sua economia também vai variar. Os cerca de 5% são o que a Anthropic reporta no conjunto de sessões com subagentes em segundo plano. A empresa não publicou uma faixa, e uma sessão com um único subagente curto tem menos a ganhar do que uma com vários longos.

Quem recebe a redução no uso dos subagentes

A Anthropic diz que a mudança está ativa para a maioria dos planos individuais e todos os planos de organização, apenas na CLI.

Onde você usa o Claude Code	Situação
Pro, Max, Ultra	Ativo para a maioria dos usuários, não para todos
Team, Enterprise	Ativo para todos
CLI	Incluído, na v2.1.316 ou posterior
App para desktop	Nada a mudar: ele não gera essa linha de status
API key, Bedrock, Vertex, Foundry	Não informado

O detalhe sobre o desktop vem de uma resposta no mesmo tópico, de Lydia Hallie, da Anthropic, que disse que o app para desktop não gera essa linha de status do subagente, então não havia nada a mudar lá.

Duas lacunas valem a pena conhecer:

“A maioria” não tem um teste público. O tópico e a documentação não citam nenhuma flag ou indicador que mostre se a sua conta Pro, Max ou Ultra já tem o recurso. Estar na versão correta é necessário, mas não prova que a mudança está ativa para você.
Quem paga por token ainda não tem resposta. A Anthropic tratou do tema em termos de limites de planos e não abordou configurações com chave de API ou provedores de nuvem. O changelog da 2.1.318 de fato altera os resumos de progresso de subagentes no Bedrock, Vertex e Foundry, ou com a telemetria desativada: com um cache de prompt frio, pode-se esperar até 5 minutos pela resposta pendente do subagente. Isso mostra que essas configurações têm um tratamento próprio, e não que recebem essa economia.

As entradas do changelog da 2.1.316 que lemos também não mencionam a linha de status, então o tópico é a única fonte para os números e a versão.

Como atualizar o Claude Code e verificar a sua versão

Três comandos resolvem:

claude --version   # needs to show 2.1.316 or later
claude update      # installs a newer version if one exists
claude --version   # confirm

O claude update também funciona em instalações feitas por gerenciador de pacotes, atualizando por meio desse gerenciador. A versão mais recente listada no changelog em 5 de novembro era a 2.1.318.

Para ver o que os subagentes consomem, execute o /usage dentro de uma sessão. Nos planos Pro, Max, Ultra, Team e Enterprise, ele atribui o uso recente a skills, subagentes, plugins e servidores MCP, em percentuais. Pressione d ou w para alternar entre 24 horas e 7 dias. Os números são aproximados e vêm do histórico local daquela máquina, então trate uma comparação antes e depois como um guia aproximado. Se você acompanha os limites de perto, o nosso guia de limites do Claude Pro e Max explica como eles funcionam.

Outras formas de gastar menos com subagentes

A correção da linha de status é automática, mas rende cerca de 5%. A documentação é clara quanto ao resto: cada subagente envia as próprias requisições, e elas contam para o mesmo limite da sua conversa principal. Essas configurações têm mais margem para ajudar.

Escolha um modelo menor. Um subagente herda o modelo da sua sessão, a menos que seja definido o contrário, então uma troca para o Opus também vale para esses subagentes. Defina model: haiku na definição de um subagente para tarefas simples. Nosso guia sobre o Claude Haiku 5.5 no Claude Code cobre essa configuração.

Para definir um padrão para todos:

{
  "env": {
    "CLAUDE_CODE_SUBAGENT_MODEL": "haiku",
    "CLAUDE_CODE_SUBAGENT_MODEL_FORCE": "1"
  }
}

A primeira variável sozinha funciona apenas como padrão. A definição de um subagente ou um modelo que o Claude passar ainda prevalece, e ela não muda os subagentes internos Explore e Plan. A segunda força um único modelo em todos os subagentes.

Reduza o nível de esforço. A versão 2.1.316 adicionou a CLAUDE_CODE_SUBAGENT_EFFORT, que define o nível de esforço dos subagentes quando nada mais especifica um, em vez de herdar o da sessão. Ela aparece no changelog, mas não estava na referência de variáveis de ambiente em 5 de novembro, então verifique os valores aceitos antes de contar com ela. Para um subagente específico, defina o campo effort documentado na definição dele (low, medium, high, xhigh ou max, dependendo do modelo).

Rode menos ao mesmo tempo. O limite padrão é de 20 subagentes em execução por sessão. Defina a CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS com um número inteiro menor se quiser um teto rígido. Execute o /tasks para ver o que está rodando e qual modelo e nível de esforço cada subagente usa.

Mantenha o escopo restrito. A documentação de custos observa que pedidos vagos disparam varreduras amplas. Um subagente orientado a verificar um único endpoint lê menos do que um encarregado de revisar a API. Nosso guia sobre criar subagentes personalizados do Claude Code detalha o formato completo das definições.

Execute testes de API em um subagente em segundo plano com a Apidog CLI

Execuções de testes de API são um bom caso para um subagente em segundo plano: demoram, produzem saída verbosa e, no fim, você só precisa das falhas. A Apidog CLI permite que o subagente execute um cenário de teste salvo enquanto a sua sessão principal segue programando, e a saída bruta fica fora do seu contexto principal.

Configure uma única vez:

npm install -g apidog-cli@latest
apidog login --with-token <YOUR_TOKEN>
npx -y skills add https://apidog.com   # pick Claude Code when prompted

Depois, adicione um subagente pequeno no arquivo .claude/agents/api-tester.md:

---
name: api-tester
description: Runs Apidog test scenarios and reports only the failures.
tools: Bash, Read
model: haiku
background: true
---
Run the Apidog test scenario you are given. Report which steps failed
and why. Don't paste the full output.

Agora, dê um único prompt ao Claude Code:

Use the api-tester subagent to run Apidog test scenario <scenarioId> in
project <projectId> against environment <environmentId>. Keep working on
the checkout refactor. When it finishes, tell me only what failed.

O subagente executa comandos como estes:

apidog test-scenario list --project <projectId>
apidog test-scenario run <scenarioId> --project <projectId> -e <environmentId> -r cli,json --out-dir apidog-reports

Pedidos de permissão de um subagente em segundo plano aparecem na sua sessão principal, indicando qual subagente está pedindo. Para execuções longas, a versão 2.1.318 também move um comando de shell para o segundo plano após 3 minutos, para que o cache de prompt não expire enquanto ele roda.

O mesmo comando run funciona em CI com -r junit, como mostra o guia de CI/CD da Apidog CLI. Para a configuração geral, consulte Apidog CLI no Claude Code. O plano Free da Apidog cobre até 4 usuários.

FAQ

Os subagentes do Claude Code agora custam 99% menos? Não. Os 99% se aplicam a cada atualização de status. A Anthropic diz que sessões com subagentes em segundo plano usaram cerca de 5% menos do limite.

Meu subagente agora roda no Haiku 5.5? Não. O subagente mantém o próprio modelo. Apenas a linha de status migrou para o Haiku 5.5.

Qual versão eu preciso? v2.1.316 ou posterior. Execute claude --version para verificar e claude update para atualizar.

Isso se aplica ao app para desktop do Claude? Não, porque não havia nada a mudar. Lydia Hallie, da Anthropic, disse que o app para desktop não gera essa linha de status do subagente.

Já está ativo no meu plano Pro? Provavelmente, mas não com certeza. A Anthropic diz que a maioria dos usuários Pro, Max e Ultra já tem o recurso, assim como todos os do Team e Enterprise. O tópico e a documentação não indicam uma forma de verificar na sua conta.

Isso ajuda se eu usar uma chave de API ou o Bedrock? A Anthropic não disse. O anúncio fala sobre limites de uso e não aborda o uso com chave de API, Bedrock ou Vertex.

O que é o ChatGPT Images 2.6? GIFs, exportação de SVG e geração 50% mais rápida

Lucas — Thu, 05 Nov 2026 10:56:39 +0000

O ChatGPT Images 2.6 é a atualização de geração de imagens da OpenAI, lançada em 4 de novembro de 2026 para o ChatGPT, o Codex e a API. Ela adiciona GIFs animados, saída em SVG para desenvolvedores, marcação em imagens e uma configuração complexity, e a OpenAI afirma que gera imagens 50% mais rápido. A API a disponibiliza como dois modelos: GPT-Image-2.6 Flare e GPT-Image-2.6 Sunburst.

Experimente o Apidog hoje

Se você leu nosso explicativo sobre o ChatGPT Images 2.5, este post cobre apenas o que mudou. Há um detalhe que o post de lançamento não menciona: as tarifas por token continuam as mesmas, mas uma imagem com qualidade low agora consome cerca de 4,2 vezes os tokens de saída que consumia na 2.5.

ChatGPT Images 2.6 em resumo

Item	Detalhe
Data de lançamento	4 de novembro de 2026 (changelog da API)
Onde está disponível	ChatGPT, Codex e a API
Acesso pelo ChatGPT e pelo Codex	Global, todos os planos de assinatura, desktop, mobile e web
IDs dos modelos na API	`gpt-image-2.6-flare`, `gpt-image-2.6-sunburst`
Alegação de velocidade	50% mais rápido que antes; Flare em apenas seis segundos com qualidade `low`
Novas saídas	GIF animado (ChatGPT e API), SVG (API)
Novos controles	Marcação de imagem, `complexity` (`low`, `medium`, `high`)
Tarifas de tokens de imagem	US$ 8 de entrada, US$ 2 de entrada em cache, US$ 30 de saída por 1M de tokens
Uso	4 bilhões de imagens por semana no ChatGPT, no Codex e na API

O que há de novo em relação ao Images 2.5

O Images 2.5 trouxe o Flare e o Sunburst, os níveis de qualidade xhigh e max, e recursos do ChatGPT como Sketch e Templates. A versão 2.6 mantém a divisão em dois modelos e os cinco níveis de qualidade, e acrescenta o seguinte:

Área	Images 2.5	Images 2.6
Saída animada	Nenhuma	GIF, de 2 a 64 quadros na API
Saída vetorial	Nenhuma	SVG, apenas na API segundo o system card
Controle de planejamento	Nenhum	`complexity`: `low`, `medium`, `high`
Edições guiadas por marcação	Primeiro no ChatGPT, suporte à API adicionado em 4 de novembro	ChatGPT e API
Tokens em `low`, 1024x1024	196	823
Preço do Batch listado	Sim	Não listado em 5 de novembro
Imagens semanais	"Mais de 3 bilhões"	4 bilhões

O system card da OpenAI também afirma que os dois modelos melhoram a consistência de edição, a preservação de detalhes e as respostas a esboços e anotações. O post de lançamento não mede nada disso com um benchmark público, nem diz a que linha de base os "50% mais rápido" se referem, então trate o número de velocidade como uma afirmação da OpenAI até cronometrar seus próprios prompts.

Quem pode usar o ChatGPT Images 2.6?

A OpenAI afirma que o Images 2.6 está disponível globalmente no ChatGPT e no Codex "em todos os planos de assinatura", em desktop, mobile e web. O acesso à API passa pelos dois modelos acima, e talvez você precise concluir a Verificação de Organização da API antes de poder chamá-los.

Duas questões continuam em aberto para os usuários do ChatGPT:

Limites de GIF no plano Free. Nem o post de lançamento nem a página de preços do ChatGPT informam uma cota de GIF. A página de preços lista a geração de imagens como "Limitada" no Free.
Thinking. A mesma página, consultada em 5 de novembro, lista "Geração de imagens com Thinking" no Plus e no Pro, mas não no Free nem no Go.

No Codex, você chama a geração de imagens com a skill $imagegen. Essa página ainda não menciona saída em GIF ou SVG.

Flare vs Sunburst: qual modelo faz o quê?

O Flare é o modelo rápido para trabalho interativo. A OpenAI diz que ele também melhora a qualidade de layout para pôsteres e imagens de produto. O Sunburst é para composições detalhadas, com qualidade superior e maior consistência entre edições nos níveis de qualidade medium ou high.

Os dois modelos custam o mesmo por token e compartilham uma única entrada na calculadora. Nossa comparação entre Flare e Sunburst na 2.5 explica essa divisão com mais profundidade, e a maior parte dela continua valendo.

Como funciona a geração de GIF

A API retorna uma animação pronta, não um sprite sheet que você mesmo monta. Os prompts de exemplo do post de lançamento pedem um sprite sheet de seis quadros em uma grade 3x2, mas o guia de geração de imagens documenta um caminho direto:

Chame POST /v1/images/generations com output_format: "gif".
Descreva o assunto, o movimento e o loop no seu prompt.
Defina frame_count (de 2 a 64, padrão 9).
Defina frame_duration_ms (de 20 a 2.000, arredondado para 10 ms, padrão 200).
Decodifique b64_json de base64 e salve com a extensão .gif.

curl --fail --silent --show-error https://api.openai.com/v1/images/generations \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-2.6-flare",
    "prompt": "A small orange robot waves, blinks, and returns to its starting pose. Loop it.",
    "output_format": "gif",
    "frame_count": 9,
    "frame_duration_ms": 200,
    "size": "auto"
  }' | jq -er '.data[0].b64_json' | base64 --decode > robot.gif

Montamos esta requisição a partir da lista de campos do guia e não a executamos com uma chave ativa, então teste antes de colocá-la em produção.

Considere estes limites no seu planejamento:

O /v1/images/edits não pode retornar GIFs, então você não consegue animar uma imagem enviada por esse endpoint.
A saída em GIF não oferece suporte a streaming, imagens parciais, output_compression personalizado nem prompt_rewriter.
A contagem de quadros, o tamanho do quadro e n precisam caber em um orçamento total de pixels. Se uma requisição falhar, reduza um deles.

Exportação em SVG: o que você recebe

Defina output_format: "svg" em POST /v1/images/generations para ícones, logos e ilustrações que precisam de caminhos, formas e cores editáveis. A API primeiro cria uma imagem de referência e depois gera o SVG a partir dela, e o quality controla essa imagem de referência.

A saída é conteúdo vetorial estático, sem scripts, recursos externos ou imagens raster incorporadas. As restrições são rígidas: n deve ser 1, não há streaming, e nem output_compression nem prompt_rewriter funcionam. O endpoint de edições não pode gerar SVG, e um SVG não pode ser uma entrada raster para edições.

A cobrança também é diferente. Você paga a tarifa do modelo de imagem pela imagem de referência, mais a tarifa de um modelo de autoria pelos tokens que escrevem o SVG. A OpenAI não publica um preço fixo por SVG, então meça com seus próprios prompts.

O parâmetro complexity e a marcação de imagem

O complexity define quanto o modelo planeja antes de renderizar. O quality define o detalhe da renderização. São controles separados, e ajustar o complexity não tem custo adicional.

Atenção ao padrão. Se você omitir complexity, os dois modelos usam high, mas a OpenAI recomenda low para a maioria das edições, combinado com a qualidade que você precisar. O guia alerta que um complexity mais alto pode aumentar a latência e introduzir mudanças indesejadas. Para trocas de fundo e correções de placas, defina low explicitamente. Reserve medium ou high para textos densos, layouts complexos e cenas com muitos elementos restritos.

A marcação de imagem chega ao POST /v1/images/edits como um campo markup. Você envia uma sobreposição transparente que circula o alvo e depois descreve a mudança no prompt. O exemplo da OpenAI circula um vaso, o recolore e pede ao modelo que remova o círculo da foto final. A marcação também funciona nos modelos 2.5 compatíveis, custa o mesmo que outras edições e não está disponível pela Responses API, onde o guia indica o uso de máscaras.

Preços do GPT-Image-2.6: mesmas tarifas, mais tokens na qualidade low

Os preços por token são iguais aos da 2.5 na página de preços: US$ 8 por 1M de tokens de entrada de imagem, US$ 2 em cache, US$ 30 de saída, US$ 5 de entrada de texto, US$ 1,25 de texto em cache. O que mudou foi o uso de tokens. A calculadora da OpenAI aplica um multiplicador de 4,2 em low e de 3,3 em medium para a 2.6, e nenhum acima disso.

Qualidade (1024x1024)	Tokens na 2.5	Custo de saída na 2.5	Tokens na 2.6	Custo de saída na 2.6
`low`	196	US$ 0,00588	823	US$ 0,02469
`medium`	439	US$ 0,01317	1.449	US$ 0,04347
`high`	1.756	US$ 0,05268	1.756	US$ 0,05268
`xhigh`	3.122	US$ 0,09366	3.122	US$ 0,09366
`max`	7.024	US$ 0,21072	7.024	US$ 0,21072

Esses números vêm da calculadora e não incluem tokens de entrada. O formato paisagem é mais barato: low em 1536x1024 usa 664 tokens, cerca de US$ 0,02.

Portanto, se você executa jobs low em alto volume na 2.5, migrar para a 2.6 multiplica sua conta de saída por cerca de 4,2. O medium na 2.6 agora custa perto do high, o que torna o high digno de teste. A aba Batch da página de preços lista a 2.5 pela metade do preço, mas não lista a 2.6, então uma carga de trabalho em batch pode sair mais barata na 2.5 por enquanto. O guia também não traz uma fórmula de cobrança específica para GIF, então faça um teste com um frame_count pequeno e verifique seu uso antes de escalar. Nosso guia da API gpt-image-2.5 cobre o básico das requisições que continua valendo.

Segurança e proveniência

A OpenAI testou os dois modelos com 3.077 prompts adversariais. Esses resultados não são taxas de produção. A proporção de gerações inseguras não bloqueadas passou de 1,92% para 1,72% no Sunburst, e de 1,49% para 2,14% no Flare, embora a OpenAI não marque nenhuma das mudanças como estatisticamente significativa.

Os GIFs trazem um novo risco, porque o dano pode aparecer ao longo dos quadros em vez de em uma imagem estática. A OpenAI relata 77,7% de recall de moderação em um conjunto adversarial de GIFs, e afirma que violações relacionadas a movimento continuam difíceis de detectar.

Para proveniência, o Images 2.6 usa metadados C2PA mais uma marca d'água invisível do SynthID no ChatGPT, no Codex e na API.

Deixe seu agente de código testá-lo com o Apidog CLI

Esta versão mudou o uso de tokens sem alterar a tabela de preços. Um teste salvo detecta uma mudança incompatível em uma requisição da qual você depende, e seu agente de código pode escrevê-lo com o Apidog CLI. Configure uma vez:

npm install -g apidog-cli@latest
apidog auth login --with-token <YOUR_TOKEN>
apidog skill install

Depois, passe um prompt para o Claude Code, o Codex ou o Cursor:

Add POST https://api.openai.com/v1/images/generations to Apidog project <id>.
Create a test case that sends model gpt-image-2.6-flare, quality low,
complexity low, output_format gif and frame_count 6, with the Bearer [REDACTED]
read from the OPENAI_API_KEY environment variable. Assert status 200 and that
data[0].b64_json exists. Run it against environment <envId> and summarize failures.

O agente lê cada schema, valida seu payload e então escreve e executa o teste:

apidog cli-schema get endpoint-create
apidog cli-schema validate endpoint-create --file endpoint.json
apidog endpoint create --project <id> --file endpoint.json
apidog cli-schema get test-case-create
apidog cli-schema validate test-case-create --file case.json
apidog test-case create --project <id> --file case.json
apidog run --test-case <caseId> --project <id> -e <envId> \
  --env-var "OPENAI_API_KEY=$OPENAI_API_KEY" -r cli,json

Cada execução faz uma geração real e cobrável, então mantenha poucos quadros e qualidade baixa. Duplique o caso com gpt-image-2.6-sunburst para comparar os dois modelos. Troque -r cli,json por -r junit para executá-lo em um pipeline de CI, e veja o guia de configuração do Claude Code para detalhes sobre o agente.

Perguntas frequentes

O ChatGPT Images 2.6 é gratuito? A OpenAI diz que ele está disponível em todos os planos de assinatura, e a página de preços lista geração de imagens limitada no plano Free. Nenhuma das fontes informa uma cota de GIF para usuários do Free. O uso da API é cobrado por token.

A API retorna um GIF ou um sprite sheet? Um GIF pronto. Defina output_format: "gif" no endpoint generations e depois decodifique b64_json. Os sprite sheets do post de lançamento vêm de prompts de exemplo.

O GPT-Image-2.6 é mais caro que a 2.5? As tarifas por token são iguais, mas imagens em low e medium usam mais tokens. Uma imagem low de 1024x1024 sobe de cerca de US$ 0,006 para cerca de US$ 0,025 em custo de saída. high, xhigh e max não mudam.

Qual é a diferença entre quality e complexity? O quality controla o detalhe da renderização e determina o custo em tokens. O complexity controla quanto o modelo planeja e tem high como padrão. A OpenAI sugere complexity low para a maioria das edições.

Posso editar uma imagem existente e transformá-la em GIF ou SVG pela API? Não. O endpoint de edições não oferece suporte a saída em GIF ou SVG, e arquivos SVG não são aceitos como entradas raster. Os dois formatos vêm apenas do endpoint generations.