Nota do autor: para desenvolvedores que assistiram à demonstração de gráficos dinâmicos em Three.js do Gemini 4 Neon e querem colocar a mão na massa, a primeira coisa a resolver não é como escrever o comando, mas sim como controlar a conta. Este artigo apresenta um método de experimentação: “primeiro definir os critérios de aceitação, depois limitar o número de tentativas e, por fim, escolher o nível de raciocínio”.
Recentemente, um vídeo de 15 segundos com gráficos dinâmicos em Three.js viralizou rapidamente entre desenvolvedores. Quem publicou afirma que ele foi feito com Three.js puro usando o Gemini 4 Neon. Muita gente, depois de assistir, tem a primeira reação de “quero fazer um também”, mas só ao começar de verdade percebe que um experimento criativo sem critérios de aceitação é o que mais facilmente queima o orçamento em repetições.
Este não é um artigo que ensina a replicar aquele vídeo, mas um guia prático para ajudar você a controlar os custos dos experimentos com o Gemini 4 Neon. O vídeo em si não divulgou nenhum dado de token, então não vamos, nem podemos, calcular um valor em dólares para ele.
Valor central: depois de ler este artigo, você vai entender por que não dá para inferir o custo a partir do vídeo final, como escrever os critérios de aceitação antes de começar, limitar o número de rodadas de tentativa e erro e o nível de raciocínio, e por que o gasto do mesmo comando na API e no Antigravity não pode ser estimado de forma misturada.

Pontos-chave para economizar no demo Gemini 4 Neon Three.js
| Ponto | Descrição | Valor |
|---|---|---|
| O vídeo final não permite inferir custo | Aquele vídeo de 15 segundos não traz comando, arquivos-fonte, nível de raciocínio nem contagem de tokens | Evita usar o trabalho de outra pessoa como base de orçamento |
| Escreva os critérios de aceitação primeiro | Antes de começar, divida “o que conta como pronto” em itens verificáveis | A cada rodada você sabe se deve continuar |
| Limite o número de tentativas | Defina um limite de rodadas para cada item de aceitação; ao ultrapassar, mude de abordagem | Evita recomeços sem fim |
| Escolha o nível de raciocínio conforme a necessidade | Tokens de raciocínio são cobrados como saída; quanto maior o nível, maior a saída | Impacta diretamente o maior item da fatura |
| Janelas de contexto diferentes por entrada | API Gemini com janela de ~1M, Antigravity até 512K | Custos de entradas diferentes não podem ser misturados no cálculo |
Por que não dá para inferir o custo a partir do vídeo de 15 segundos do Gemini 4 Neon
Segundo a compilação do OrcaRouter de 19/11/2026, esse vídeo foi publicado por @chetaslua naquele dia às 16:51 UTC, com especificação de 15 segundos e 1920×1080; o autor do post afirma que se trata de motion graphics feito com Gemini 4 Neon usando three.js puro. Mas o post não traz comando, não traz arquivos-fonte, não diz qual nível de raciocínio foi usado, nem a contagem de tokens — e nem sequer menciona se rodou na API, no AI Studio ou no Antigravity.
Isso significa que “o Gemini 4 Neon fez este vídeo” é apenas uma atribuição de quem postou, não uma medição. Você não sabe quantas rodadas foram necessárias, não sabe quanto foi alterado manualmente no meio do caminho, nem quanto da saída era token de raciocínio. Usar um resultado assim para estimar “mais ou menos quanto vou gastar” pode gerar um erro de ordem de magnitude.
A demonstração oficial do Google com o Gemini 4 Neon também não traz fatura
Não é só o trabalho da comunidade: o simulador de esqui, o gabinete Turing, a tabela de cem mil células e a bancada de experimentos Blender MCP que o próprio Google mostrou no anúncio de lançamento em 18/11/2026 também não divulgaram fatura de tokens. No post oficial do Google no X em 19 de novembro, sobre o parkour 3D de Shibuya, ele menciona o uso de quase 1 milhão de tokens de dados do OpenStreetMap — esse é o volume de entrada autodeclarado pela empresa, não uma fatura completa; as partes de saída e de raciocínio continuam desconhecidas.
O anúncio também cita rankings de terceiros: o Artificial Analysis Intelligence Index fica em 61 no nível xhigh, com 3º lugar no ranking geral, e o Vals Index fica em 2º lugar, com pontuação de 70.9%. Esses são rankings de terceiros citados no anúncio do Google, que mostram posicionamento de capacidade e igualmente não contêm nenhuma informação sobre “quanto custa fazer uma demonstração”. Demonstrações e notas de ranking ajudam a decidir se vale a pena tentar, mas não fazem o orçamento por você.

Demonstração do Gemini 4 Neon Three.js: escreva os critérios de aceitação antes de pôr a mão na massa
A maior armadilha de custo em tarefas criativas é o “sinto que ainda falta um pouco”. Quando não existe critério, toda rodada de resultado sempre tem algo para criticar, e aí você fica repetindo indefinidamente. Escrever os critérios de aceitação logo no começo é, na essência, dar a si mesmo uma condição de parada, para que cada invocação tenha um passou ou não passou bem claro.
Os critérios de aceitação precisam ser o mais verificáveis possível, e não palavras subjetivas como “bonito” ou “com textura”. A seguir, uma forma de decomposição que pode servir de referência para um experimento de gráficos dinâmicos com Three.js:
| Dimensão de aceitação | Formulação verificável | Formulação não recomendada |
|---|---|---|
| Execução | Arquivo HTML único, abre no navegador sem erros | Só precisa rodar |
| Dependências | Usar apenas three.js, sem introduzir outras bibliotecas de animação | O mínimo possível de dependências |
| Duração e ritmo | Duração do loop de cerca de 15 segundos, dividido em três segmentos de câmera | O ritmo tem que ser bom |
| Elementos visuais | Especificar a ordem de grandeza da quantidade de partículas, o tipo de geometria e o esquema de cores | Precisa ser impressionante |
| Desempenho | Reprodução fluida em um notebook comum, sem queda perceptível de frames | Não pode travar muito |
| Limite de entrega | Não precisa exportar vídeo, apenas código-fonte executável | Fazer mais completo |
Depois de escrever essa tabela, você vai perceber que muitas ideias na verdade podem ser divididas em rodadas diferentes para serem verificadas separadamente. Por exemplo, a primeira rodada pode exigir apenas “roda + usa só three.js + composição básica”, e depois adicionar ritmo e detalhes visuais item por item, em vez de exigir tudo de uma vez logo de cara.
Como limitar as tentativas de erro do Gemini 4 Neon para tentar menos vezes
Com a lista de verificação em mãos, o próximo passo é definir um limite de rodadas para cada item de aceitação. O limite específico fica a seu critério conforme o orçamento; uma prática bem útil é: se o mesmo item de aceitação falhar por várias rodadas seguidas, pare e mude de abordagem, em vez de continuar adicionando comandos de “tente de novo”. Mudar de abordagem pode significar dividir a tarefa em partes menores, fornecer uma estrutura de referência, ou colar de volta apenas o trecho de código que deu erro e pedir ao modelo para alterar só aquele ponto.
Outro ponto que costuma passar despercebido é o acúmulo de contexto. Em conversas de várias rodadas, cada rodada reenvia o código e a discussão anteriores como entrada; quanto mais rodadas, mais pesada fica a entrada de cada uma. Uma abordagem mais econômica é: sempre que um item de aceitação passar, organize o código-fonte atual que funciona em um novo ponto de partida limpo e abra uma nova sessão para continuar, em vez de se arrastar numa conversa cada vez mais longa.
- Em cada rodada, faça exigências sobre apenas um ou dois itens de aceitação.
- Ao final de cada rodada, registre os tokens de entrada e saída no usage e calcule o custo daquela rodada.
- Ao atingir o limite de rodadas, pare, revise os motivos da falha e só então decida se continua.
- A cada item concluído, “arquive” o código-fonte e avance para o próximo item numa nova sessão.
🎯 Sugestão de teste: se você quer ver com clareza o custo de cada rodada, pode rodar os testes na APIYI apiyi.com com a mesma chave API, com cobrança por uso — o consumo de tokens de cada chamada fica registrado e conferível, o que é bem mais controlável do que estimar de cabeça na interface interativa.
Como escolher o nível de raciocínio do Gemini 4 Neon e quando parar
O nível de raciocínio é o ajuste mais direto para controlar a conta no experimento do Gemini 4 Neon. Segundo a documentação do Google Cloud, o thinking_level do Neon tem quatro níveis — LOW, MEDIUM, HIGH (padrão) e XHIGH — e os tokens de raciocínio são cobrados como saída. O preço de saída já é cinco vezes o de entrada; quanto mais alto o nível e mais longo o raciocínio, mais rápido a conta sobe. Vale notar que o parâmetro thinking_budget e o nível MINIMAL retornam HTTP 400 direto no Neon — não replique o padrão antigo de outros modelos.
O nível de raciocínio também não é igual para toda a família; fique atento ao trocar de modelo:
| Modelo | Níveis de raciocínio disponíveis | Nível padrão | Uso recomendado oficial (documentação do Neon) |
|---|---|---|---|
gemini-4-neon |
low / medium / high / xhigh | high | LOW para resumos de classificação, MEDIUM para codificação geral, HIGH para ciclos de ferramentas em várias etapas, XHIGH para as provas mais pesadas e engenharia com vários arquivos |
gemini-4-hydrogen |
low / medium / high / xhigh | high | Tem nível xhigh |
gemini-4-carbon |
low / medium / high | medium | Não tem xhigh |
Para uma animação dinâmica em Three.js de arquivo único, isso se parece mais com “codificação geral”, então começar em MEDIUM faz sentido. Só eleve um item específico para HIGH quando um critério de aceitação continuar falhando repetidamente em MEDIUM e o motivo da falha for realmente complexidade lógica (por exemplo, a montagem da linha do tempo com várias cenas). XHIGH é mais adequado a projetos com vários arquivos; animações de página única raramente precisam dele.
A decisão de quando parar de subir de nível também precisa estar nas regras: se, depois de elevar o nível, o mesmo item ainda não passar, o problema provavelmente não é “raciocínio insuficiente”, mas sim o próprio requisito mal descrito. Nesse caso, continuar subindo de nível só aumenta o custo de saída.
💡 Sugestão de nível: Ao chamar o Gemini 4 Neon na APIYI (apiyi.com), você pode rodar o mesmo critério de aceitação uma vez com
MEDIUMe outra comHIGH, comparar os tokens de saída no campo usage e a taxa de aprovação, e então decidir qual nível usar como padrão daqui em diante.
Diferenças de janela do Gemini 4 Neon entre a API e o Antigravity
Mesmo modelo, porta de entrada diferente — e o que cabe lá dentro muda. Na API Gemini, o contexto do Neon é de 1,048,576 token, enquanto a documentação do Antigravity afirma que o Gemini 4 Neon tem contexto de no máximo 512K token, ou seja, cerca de metade. A forma de escrever o nível de pensamento também é outra: na interface do Antigravity aparece como Low, Medium, High (padrão) e Extra; na CLI, escreve-se low, medium, high, xhigh.
| Item de comparação | Gemini API | Antigravity |
|---|---|---|
| Janela de contexto | 1,048,576 token | até 512K token |
| Forma de escrever o nível de pensamento | thinking_level: LOW / MEDIUM / HIGH / XHIGH |
Interface Low / Medium / High / Extra; CLI low / medium / high / xhigh |
| Nível de pensamento padrão | HIGH | High |
| Como o custo é contabilizado | Cada chamada é cobrada por token e dá para conferir direto na fatura | Vale o que dizem as regras internas do produto; não convém misturar com o preço unitário da API |
O ponto desta tabela é simples: o mesmo comando, nos dois pontos de entrada, tem janela disponível e forma de gerenciar o contexto diferentes — e o consumo, naturalmente, também muda. O orçamento estimado na API não pode ser transplantado direto para o Antigravity; e, na direção contrária, achar que “gastou pouco” no Antigravity não quer dizer que sairia igualmente barato na API. Um cenário como aquele corre-corre em Shibuya, com entrada na casa de 1 milhão de tokens, simplesmente não cabe numa janela de 512K: ou você fatia os dados, ou troca de porta de entrada.

Início rápido com Gemini 4 Neon: rode seu primeiro teste com Three.js usando a API
Configuração mínima de requisição do Gemini 4 Neon
A APIYI oferece uma interface compatível com OpenAI, com dois endpoints — chat e gemini — e os grupos Default e SVIP. Para o primeiro teste, basta confirmar as seguintes configurações:
- Endereço da API: defina
base_urlcomohttps://api.apiyi.com/v1 - ID do modelo:
gemini-4-neon - Chave API: crie no console e preencha; nos exemplos, ela aparece como
YOUR_API_KEY - Nível de raciocínio: conforme sugerido acima, comece com
MEDIUM; no endpoint gemini, use o campothinking_level; o mapeamento de campos no endpoint chat deve seguir a documentação da plataforma - Conteúdo do comando: cole diretamente a checklist de aceitação que você escreveu e declare “entregue apenas um único arquivo HTML e use somente three.js”
Ao final de cada rodada de chamadas, registre o campo usage retornado. O custo por rodada pode ser estimado com esta fórmula: tokens de entrada × preço unitário de entrada + tokens de cache hit × preço unitário de cache + (tokens de saída visível + tokens de raciocínio) × preço unitário de saída.
Sobre o preço, vale esclarecer um ponto: a tabela geral de modelos da APIYI na versão de 2026-11-19 10:59 (UTC+8) ainda não listava gemini-4-neon, e o Neon também não tinha uma página de modelo independente; porém, na API de preços consultada em 2026-11-20, ele já aparecia, com valores convertidos em entrada de 3 dólares/milhão de tokens, saída de 15 dólares/milhão de tokens e leitura de cache de 0.15 dólar/milhão de tokens, iguais aos preços de tabela do Google. O preço real deve ser confirmado na lista de modelos da plataforma.
🚀 Início rápido: recomendo primeiro se cadastrar na APIYI (apiyi.com) e resgatar o crédito de teste gratuito para novos usuários, usá-lo para concluir o primeiro item da checklist de aceitação e, só depois de obter dados reais de
usage, planejar o orçamento dali em diante. Isso é muito mais confiável do que chutar com base no resultado final de outra pessoa.
Perguntas frequentes (FAQ)
P1: A demonstração Three.js do Gemini 4 Neon é um benchmark oficial?
Não. Aquele vídeo de 15 segundos foi publicado por um usuário da comunidade, e a atribuição do modelo vem do próprio autor do post — não há comando, arquivo-fonte, nível de raciocínio nem número de tokens. Trata-se de uma demonstração, não de uma medição, e não serve como benchmark oficial nem referência de custo.
P2: Dá para estimar o custo de fazer uma demonstração parecida com base no vídeo final?
Não. Quantas tentativas foram feitas, qual nível de raciocínio foi usado, se houve edição manual — nada disso é conhecido, e os tokens de raciocínio são cobrados como saída. Qualquer uma dessas variáveis pode fazer o custo variar muito. O jeito confiável é rodar a sua própria tentativa e calcular com os dados de usage.
P3: O que as pontuações do Gemini 4 Neon nos rankings dizem?
O anúncio do Google citou rankings de terceiros: o Artificial Analysis Intelligence Index em xhigh é 61, com 3º lugar no ranking geral; o Vals Index é 2º, com 70,9%. Esses números refletem a posição em capacidade e ajudam a avaliar se vale a pena testar, mas não trazem nenhuma informação de custo.
P4: Qual nível de raciocínio usar para gráficos dinâmicos em Three.js?
Animações em arquivo único estão mais próximas de codificação comum; recomendo começar com `MEDIUM` e subir para `HIGH` apenas quando algum item de aceitação complexo falhar repetidamente. O `XHIGH` é voltado para projetos com múltiplos arquivos e as inferências mais pesadas, então normalmente não é necessário para animações de página única.
P5: Como chamar rapidamente o Gemini 4 Neon via API para fazer testes?
Registre-se na APIYI apiyi.com e obtenha uma chave API, defina `base_url` como o endereço da plataforma e `model` como `gemini-4-neon`; depois basta especificar explicitamente o nível de raciocínio e enviar a lista de aceitação. Novos usuários têm cota gratuita de teste, ideal para rodar o primeiro item de aceitação e obter o uso real.
P6: Quais são as armadilhas mais comuns ao testar o Gemini 4 Neon?
– Parâmetros: `thinking_budget` e `MINIMAL` retornam HTTP 400.
– Janela: o Antigravity tem no máximo 512K, então não planeje entradas com base nos 1M da API.
– Troca de modelo: o Carbon não tem xhigh, e o nível padrão também é diferente.
– Preço: a planilha geral na versão de 19 de novembro não lista o Neon; use a lista de modelos da plataforma como referência.
Principais conclusões para economizar na demo Three.js do Gemini 4 Neon
- Vídeo final não é fatura: o filme de 15 segundos não traz dados de tokens, então não dá para deduzir o custo.
- Demos oficiais também não têm fatura: as demonstrações do Google não divulgaram a conta de tokens.
- Aceitação antes do comando: transforme o “ficou pronto” em itens verificáveis antes de pôr a mão na massa.
- Tentativa e erro precisa de limite: defina um teto de rodadas para cada item; se passar, mude a abordagem em vez de insistir.
- O nível de pensamento é o botão principal: os tokens de pensamento são cobrados como saída; comece pelo MEDIUM.
- Estime as entradas separadamente: a API tem janela de cerca de 1M, o Antigravity vai até 512K.
- Os modelos podem dividir tarefas: Carbon e Hydrogen têm preço unitário menor; ao trocar, atenção às diferenças de nível.
Resumo
Os pontos essenciais para economizar na demo Three.js do Gemini 4 Neon:
- Não se deixe levar pelo vídeo final: nem os vídeos da comunidade nem as demos oficiais divulgam a fatura; o orçamento só pode vir dos seus próprios dados de uso.
- Primeiro a aceitação, depois o limite de tentativas: a lista de aceitação dá a condição de parada, e o teto de rodadas evita repetições infinitas; só os dois juntos realmente controlam o gasto.
- Gerencie níveis e entradas separadamente: o nível de pensamento define o volume de saída, a entrada define o tamanho da janela; ao trocar de modelo, confira também os níveis disponíveis e o padrão.
Antes de começar, gastar dez minutos escrevendo a lista de aceitação costuma economizar mais do que ficar tentando mais rodadas. A recomendação é usar a cota gratuita via APIYI apiyi.com para validar o primeiro item de aceitação, e depois usar uma única chave API para dividir as tarefas entre Neon, Carbon e Hydrogen; os preços seguem a lista de modelos da plataforma.
📚 Referências
-
OrcaRouter — Compilação dos gráficos em movimento (Three.js) do Gemini 4 Neon: data de publicação, especificações e lacunas de informação do vídeo da comunidade
- Link:
orcarouter.ai/blog/gemini-4-neon-threejs-motion-graphic - Descrição: registra que o vídeo não traz o comando, os arquivos-fonte, o nível de raciocínio (thinking level) nem a contagem de tokens
- Link:
-
Google Blog — Anúncio de lançamento do Gemini 4 Neon: preços oficiais, contexto e rankings de terceiros citados
- Link:
blog.google/innovation-and-ai/models-and-research/gemini-models/introducing-gemini-4-neon - Descrição: inclui a apresentação da demonstração oficial e os preços unitários de entrada, cache e saída
- Link:
-
Google Cloud — Guia do modelo Gemini 4 Neon: níveis de raciocínio e limites de parâmetros
- Link:
docs.cloud.google.com/gemini-enterprise-agent-platform/models/guides/gemini-4-neon - Descrição: explica a finalidade dos quatro níveis de
thinking_levele os parâmetros que provocam HTTP 400
- Link:
-
Documentação de modelos do Antigravity: janela de entrada e como declarar o nível de raciocínio
- Link:
antigravity.google/docs/models - Descrição: lista a janela de contexto máxima de 512K do Neon no Antigravity
- Link:
Autor: Equipe técnica da APIYI
Contato técnico: fale conosco pela página inicial do site da APIYI. Para mais modelos e instruções de invocação, acesse a central de documentação em docs.apiyi.com
