Níveis de raciocínio do Gemini 4 Neon: quando usar High vs xhigh

O Gemini 4 Neon tem quatro níveis de raciocínio e usa high como padrão. Veja como definir thinking_level na Interactions API e no generateContent, quanto custa cada nível e quando mudar de high para xhigh.

INEZA Felin-Michel

INEZA Felin-Michel

19 novembro 2026

Níveis de raciocínio do Gemini 4 Neon: quando usar High vs xhigh

Apidog para empresas

Implantação local

SSO & RBAC

Conforme SOC 2

Explorar Apidog Enterprise

Os níveis de raciocínio do Gemini 4 Neon oferecem quatro configurações para definir o quanto o modelo raciocina antes de responder: low, medium, high e xhigh. O Neon usa high por padrão. O Google recomenda manter high para a maioria dos trabalhos complexos e mudar para xhigh apenas quando high falhar em problemas difíceis e com várias etapas, porque xhigh consome mais tokens e leva mais tempo.

O que são os níveis de raciocínio do Gemini 4 Neon?

Os níveis de raciocínio são valores do parâmetro thinking_level que definem quanto raciocínio interno o gemini-4-neon realiza antes de escrever uma resposta. O Neon oferece quatro: low, medium, high (o padrão) e xhigh. Níveis mais altos usam mais tokens de raciocínio e aumentam a latência; níveis mais baixos respondem mais rápido e custam menos.

Veja como o guia de raciocínio do Google descreve cada nível para o Neon:

thinking_level Uso de tokens Uso sugerido pelo Google
low Menos tokens, menor latência Chat rápido, processamento de alto volume; ainda competente em tarefas agênticas
medium Menor uso de tokens, respostas mais rápidas Programação interativa, prototipagem de UI ao vivo, chamadas de ferramentas sensíveis à latência
high (padrão) Inteligência e velocidade equilibradas Programação complexa, execução agêntica, chamada de ferramentas, trabalho de conhecimento multimodal
xhigh Mais tokens, raciocínio mais profundo Engenharia difícil com várias etapas, problemas analíticos e científicos em que high não é suficiente

Faltam dois valores que você talvez esperasse. O Neon rejeita minimal com um erro, então códigos copiados de um app com Gemini 3 Flash quebram se enviarem esse valor. E a contagem de tokens antiga do thinkingBudget está obsoleta no Gemini 4: enviada sozinha, ela é mapeada para o nível mais próximo com um aviso; enviada junto com thinkingLevel, retorna um 400.

Escada dos quatro níveis de raciocínio do Gemini 4 Neon, de low a xhigh, com tokens de raciocínio e latência aumentando a cada passo e high marcado como padrão

Como o padrão do Neon se compara aos outros modelos Gemini 4?

O Neon começa um nível acima dos modelos maiores da mesma família. Segundo as notas de lançamento do Gemini 4 Neon, Neon e Hydrogen usam high por padrão e suportam xhigh, enquanto Carbon e Argon usam medium por padrão e têm limite em high.

Modelo Nível padrão Níveis suportados
gemini-4-neon high low, medium, high, xhigh
gemini-4-hydrogen high low, medium, high, xhigh
gemini-4-carbon medium low, medium, high
gemini-4-argon medium low, medium, high

Isso importa quando você troca de modelo. Migre uma carga de trabalho do Carbon para o Neon sem definir thinking_level e cada requisição passa de raciocínio medium para high, o que altera sua contagem de tokens. Se você está avaliando os modelos maiores, nossa comparação Gemini 4 Carbon vs Argon cobre essa diferença.

Como definir thinking_level na Gemini API?

O Neon roda no nível pago tanto da Interactions API quanto do generateContent. O nome do campo difere entre elas.

Interactions API: coloque thinking_level dentro de generation_config.

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-neon",
    "input": "Audit this payment retry queue for race conditions.",
    "generation_config": {
      "thinking_level": "xhigh",
      "max_output_tokens": 65536
    }
  }'

generateContent: use thinkingLevel dentro de generationConfig.thinkingConfig.

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-4-neon:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -X POST \
  -d '{
    "contents": [{"parts": [{"text": "Audit this payment retry queue for race conditions."}]}],
    "generationConfig": {
      "thinkingConfig": {"thinkingLevel": "medium"}
    }
  }'

No SDK Python, a chamada da Interactions recebe generation_config={"thinking_level": "high"}, e a chamada do generateContent recebe thinking_config=types.ThinkingConfig(thinking_level="low"). Deixe de fora temperature, top_p e top_k: o Google diz que o Neon ignora valores dentro do intervalo e rejeita os fora do intervalo com um 400. Para um passo a passo completo da primeira requisição com o mesmo design de API, veja nosso guia da Gemini 4 Hydrogen API.

Quando usar high ou xhigh?

Use high por padrão e promova uma tarefa para xhigh só depois que high não atingir seu padrão de qualidade nela. O post de lançamento do Google descreve xhigh como “raciocínio mais profundo e com várias etapas para as cargas de trabalho de engenharia, análise e ciência mais difíceis”.

Escolha xhigh quando:

Fique em high (ou desça mais) quando:

Os números de benchmark do Google confirmam essa divisão. No anúncio de lançamento, o Neon em xhigh marca 61 no Artificial Analysis Intelligence Index, ficando em terceiro lugar. No high padrão, o Google reporta um custo por tarefa 32% menor que o Carbon. Esses são os números do Google, não nossos testes, mas mostram a troca: xhigh entrega a pontuação mais alta do Neon, e high entrega eficiência.

Quanto custa cada nível de raciocínio?

Todos os níveis têm o mesmo preço por token; o que muda é quantos tokens você paga. O Neon custa US$ 3,00 por 1 milhão de tokens de entrada e US$ 15,00 por 1 milhão de tokens de saída, e a página de preços do Google informa que a tarifa de saída inclui os tokens de raciocínio. A entrada em cache cai para US$ 0,15 por 1 milhão via cache implícito (o cache explícito não é suportado no Neon). Não há nível gratuito para este modelo.

Assim, o custo de um nível é o número de tokens de raciocínio que ele adiciona, multiplicado por US$ 15 por milhão. Veja a aritmética para uma requisição com 2.000 tokens de entrada e uma resposta visível de 800 tokens. As contagens de tokens de raciocínio são hipotéticas, escolhidas para mostrar o cálculo, não medidas:

Tokens de raciocínio (hipotéticos) Custo de entrada Custo de saída + raciocínio Total por requisição Por 10.000 requisições
500 $0,006 $0,0195 $0,0255 $255
2.000 $0,006 $0,042 $0,048 $480
8.000 $0,006 $0,132 $0,138 $1.380

O raciocínio domina a conta rapidamente. Com 8.000 tokens de raciocínio, ele representa 87% do custo da requisição. Por isso o próprio Google recomenda rodar sua avaliação em todos os quatro níveis e “escolher o thinking_level mais baixo que atenda ao seu padrão de qualidade”. Nosso guia de níveis de raciocínio do Gemini 3.8 Flash cobre a mesma troca em um modelo mais barato, caso queira comparar.

Como medir tokens e latência por nível?

Rode o mesmo prompt em cada nível e leia o bloco de uso. Na Interactions API, o objeto usage da resposta reporta total_input_tokens, total_output_tokens e total_thought_tokens separadamente. No generateContent, os tokens de raciocínio aparecem como usageMetadata.thoughtsTokenCount.

Este loop envia um prompt nos quatro níveis e imprime os tokens de raciocínio mais o tempo de execução:

for level in low medium high xhigh; do
  start=$(date +%s)
  usage=$(curl -s "https://generativelanguage.googleapis.com/v1beta/interactions" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -H 'Content-Type: application/json' \
    -d "{\"model\":\"gemini-4-neon\",
         \"input\":\"Find the race condition in this retry loop: ...\",
         \"generation_config\":{\"thinking_level\":\"$level\",\"max_output_tokens\":65536}}" \
    | jq -c '{status, thought: .usage.total_thought_tokens, out: .usage.total_output_tokens}')
  echo "$level $(( $(date +%s) - start ))s $usage"
done

Rode com 10 a 20 prompts da sua carga de trabalho real. Um único prompt diz pouco; um conjunto mostra onde high e xhigh começam a divergir em qualidade.

Configure um timeout alto no seu cliente HTTP durante os testes. As notas de migração do Google dizem que prompts difíceis podem levar vários minutos e sugerem um timeout de pelo menos 15 minutos, ou execução em segundo plano.

Por que xhigh às vezes retorna uma resposta vazia?

max_output_tokens limita o raciocínio e a saída visível juntos. Se o Neon gastar todo o orçamento raciocinando, a interação termina com status incomplete e retorna uma resposta truncada ou vazia, e você ainda paga pelos tokens de raciocínio gerados.

Três regras da documentação do Google evitam isso:

  1. Remova limites baixos antigos. Se seu app tem algo como 8.192 fixo no código, aumente para 65.536, o limite síncrono padrão.
  2. Baixe o nível, não o limite. Para reduzir custo ou latência, mude para medium ou low em vez de diminuir max_output_tokens.
  3. Use segundo plano para trabalhos longos. Para respostas acima de 65.536 tokens, defina background como true e max_output_tokens até 1.048.576 menos sua entrada. Entrada, raciocínio e saída compartilham uma única janela de 1M de tokens. Nosso guia de saída longa do Gemini 4 Argon explica o padrão de polling.

Deixe seu agente de programação testar os quatro níveis com o Apidog CLI

Repetir esse loop manualmente cansa. Em vez disso, deixe seu agente de programação (Claude Code, Codex, Cursor) montar um teste reutilizável com o Apidog CLI e rodá-lo em cada nível sempre que quiser números atualizados.

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ê um único prompt ao seu agente:

In Apidog project <projectId>, create an environment "gemini" with base URL
https://generativelanguage.googleapis.com and variables GEMINI_API_KEY and
THINKING. Add an endpoint for POST /v1beta/interactions that sends the
x-goog-api-key header from GEMINI_API_KEY. Create a test case that sends model
"gemini-4-neon", my audit prompt, generation_config.thinking_level {{THINKING}}
and max_output_tokens 65536, and asserts: HTTP 200, status is "completed",
and usage.total_thought_tokens exists. Run it once per level (low, medium,
high, xhigh) and give me a table of thought tokens and response time.

O agente lê o schema de cada payload, valida o JSON, cria os recursos e executa o loop:

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
for level in low medium high xhigh; do
  apidog run --test-case <caseId> --project <projectId> -e <envId> \
    --env-var "THINKING=$level" -r cli,json --out-file "neon-$level"
done
Fluxo de um prompt do agente passando por apidog environment create, endpoint create, test-case create e quatro comandos apidog run em low, medium, high e xhigh contra o gemini-4-neon, terminando em uma tabela de comparação vazia de tokens de raciocínio e tempo

A asserção status is "completed" captura a armadilha do incomplete da seção anterior, de modo que um nível que fica sem orçamento falha de forma explícita em vez de retornar uma string vazia. 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 atende até 4 usuários.

Perguntas frequentes

Qual é o nível de raciocínio padrão do Gemini 4 Neon? high. Você não precisa enviar thinking_level para obtê-lo. Carbon e Argon usam medium por padrão, então defina o nível explicitamente ao migrar deles.

O Gemini 4 Neon suporta raciocínio mínimo (minimal)? Não. O Neon suporta low, medium, high e xhigh, e rejeita minimal com um erro. Use low para as respostas mais rápidas e baratas.

Os tokens de raciocínio são cobrados no Gemini 4 Neon? Sim. Os tokens de raciocínio são cobrados na tarifa de saída de US$ 15,00 por 1 milhão. O Google conta todos os tokens que o modelo processa, incluindo os tokens de raciocínio.

Ainda posso usar thinkingBudget com o Gemini 4 Neon? Está obsoleto nos modelos Gemini 4. Enviado sozinho, ele é mapeado para o thinkingLevel mais próximo e retorna um aviso. Enviado junto com thinkingLevel, a requisição falha com um 400.

xhigh é sempre mais preciso que high? Não sempre. O Google diz que xhigh pode raciocinar em excesso em prompts simples, como extração de texto ou JSON, e pode esgotar max_output_tokens. Teste ambos com seus próprios prompts e fique com o nível mais baixo que passar.

Posso usar os níveis de raciocínio do Gemini 4 Neon gratuitamente? Não. O Gemini 4 Neon não está disponível no nível gratuito da Gemini API. No Google AI Studio e no Google Antigravity, ele está vinculado aos planos pagos Google AI Pro e Ultra.

Pratique o design de API no Apidog

Descubra uma forma mais fácil de construir e usar APIs