Gemini 4 Argon, 1M de Tokens de Saída: O Que Uma Resposta Milionária Faz na Sua Pilha de APIs

O número principal do Gemini 4 Argon — 1 milhão de tokens — é o limite de saída, não a janela de contexto. Segundo o Google, uma única resposta do Argon pode atingir 1 milhão de tokens, cerca de 16 vezes o limite anterior de 64K. A janela de entrada do Argon ainda não foi publicada. Também não há um endpoint público para chamar: hoje, o Argon está disponível apenas para participantes do Fairwind Program, com clientes pagantes da API previstos para quando o Google abrir o acesso. Consulte o guia de data de lançamento e acesso.

Experimente o Apidog hoje

Uma resposta desse tamanho quebra premissas comuns em integrações de API: a chamada pode durar minutos, o corpo não cabe com segurança na memória e o custo por requisição deixa de ser pequeno e previsível. Neste guia, você vai preparar sua aplicação para respostas longas: calcular custos, usar streaming, configurar timeouts, limitar saída, armazenar resultados e testar o fluxo no Apidog. Para uma visão geral do modelo, consulte o que é o Gemini 4 Argon; para formatos de solicitação, veja o guia da API Gemini 4 Argon.

1M de tokens de saída não é uma janela de contexto de 1M

Algumas páginas descrevem os 1M de tokens como janela de contexto ou como uma “janela de contexto 16 vezes maior”. Isso não corresponde ao que o Google publicou.

A publicação de lançamento afirma que o Argon expandiu “o limite de tokens de saída do modelo para um recorde da indústria de 1M de tokens”. A comparação com 64K corresponde ao limite de saída de 65.536 tokens do Gemini 3.1 Pro Preview.

A entrada é uma especificação separada e ainda não foi divulgada. A metodologia de avaliação cita testes com prompts entre 256K e 1M de tokens, mas isso é um cenário de benchmark, não uma garantia de produto.

Há também uma ressalva prática para a saída: a Vals AI lista uma saída máxima de 262K para a configuração do Argon que testou. O Google declara um limite de modelo de 1M, enquanto um avaliador externo observou um limite menor no endpoint utilizado.

Modelo	Saída máxima por resposta	Janela de entrada ou contexto
Gemini 4 Argon	1M (limite declarado pelo Google)	Não publicado
Gemini 3.1 Pro Preview	65.536	1.048.576
Gemini 3.8 Flash	65.536	1.048.576
GPT-6 Astra	128.000	1.050.000 (922K entrada máxima)
Claude Opus 5.5	128K (300K no Batch com um cabeçalho beta)	1M

Os concorrentes listados limitam a saída síncrona a 128K. Portanto, o limite declarado de 1M do Argon é cerca de oito vezes maior. A justificativa do Google é permitir que o modelo gere centenas de milhares de tokens em uma única trajetória para resolver problemas complexos em uma passagem.

Para comparar arquiteturas de tarefas longas, veja as tarefas de 18 horas do Claude Opus 5.5 e o guia da API GPT-6 Astra.

Quanto custa uma resposta com limite máximo

Comece pelo pior caso: a saída custa US$ 10 por 1M de tokens durante o período de introdução e US$ 20 depois.

Para uma saída de 1 milhão de tokens:

• Introdução: 1.000.000 × US$ 10 / 1M = US$ 10,00
• Preço padrão: 1.000.000 × US$ 20 / 1M = US$ 20,00

A entrada é cobrada separadamente. Um prompt de 200.000 tokens adiciona:

• Introdução: 200.000 × US$ 2 / 1M = US$ 0,40
• Preço padrão: US$ 0,80

Assim, uma chamada máxima com esse prompt pode custar:

Cenário	Saída	Entrada	Total
Taxa de introdução	US$ 10,00	US$ 0,40	US$ 10,40
Taxa padrão	US$ 20,00	US$ 0,80	US$ 20,80

Um job noturno com 100 chamadas desse porte custaria US$ 1.040 nas taxas de introdução.

Os tokens de pensamento tornam a estimativa menos óbvia. Nos modelos Gemini atuais, eles são cobrados como saída. O Google ainda não informou se o Argon segue a mesma regra ou se o pensamento conta para o limite de 1M. Em ambos os casos, uma resposta visível curta pode gerar uma cobrança de saída relevante.

Para cenários adicionais, incluindo entrada em cache com 95% de desconto, consulte o guia de preços do Gemini 4 Argon.

Por que o streaming é obrigatório

Sem streaming, o cliente não recebe bytes até que toda a geração termine. Para respostas com centenas de milhares de tokens, isso cria uma conexão silenciosa longa. Qualquer timeout de inatividade no cliente, proxy, gateway ou balanceador pode encerrar a chamada antes do primeiro byte.

Use streaming.

No generateContent, altere o método para:

:streamGenerateContent?alt=sse

O Google envia eventos Server-Sent Events (SSE), com candidatos parciais em cada evento. Processe cada evento assim que ele chegar e grave o conteúdo incrementalmente. Não acumule toda a resposta em memória.

O exemplo abaixo usa o Gemini 3.8 Flash como substituto, já que o Google ainda não publicou o ID do modelo Argon. Consulte também o guia da API Gemini 3.8 Flash.

import json
import os

import requests

MODEL = os.environ.get("GEMINI_MODEL", "gemini-3.8-flash")
URL = (
    "https://generativelanguage.googleapis.com/v1beta/models/"
    f"{MODEL}:streamGenerateContent?alt=sse"
)

body = {
    "contents": [
        {
            "parts": [
                {
                    "text": "Write a test plan for every endpoint in a payments API."
                }
            ]
        }
    ],
    "generationConfig": {
        "maxOutputTokens": 60000
    },
}

usage = None

with (
    requests.post(
        URL,
        json=body,
        stream=True,
        timeout=(10, 120),
        headers={"x-goog-api-key": os.environ["GEMINI_API_KEY"]},
    ) as response,
    open("response.txt", "a", encoding="utf-8") as output,
):
    response.raise_for_status()

    for line in response.iter_lines(decode_unicode=True):
        if not line or not line.startswith("data:"):
            continue

        event = json.loads(line[5:])

        for candidate in event.get("candidates", []):
            for part in candidate.get("content", {}).get("parts", []):
                output.write(part.get("text", ""))

        output.flush()
        usage = event.get("usageMetadata", usage)

print(usage)

Neste exemplo:

• timeout=(10, 120) define 10 segundos para conexão e 120 segundos para leitura.
• Em requests, o timeout de leitura é o maior intervalo permitido entre bytes, não a duração total da requisição.
• Se o servidor continuar emitindo eventos, o stream pode permanecer aberto pelo tempo necessário.
• Cada fragmento é persistido no disco assim que chega.
• No Gemini 3.8 Flash, o último evento pode incluir o usageMetadata final para auditoria e cobrança.

Timeouts em cada salto

Seu cliente HTTP é apenas um dos componentes do caminho. Um stream longo pode atravessar proxy reverso, gateway de API, balanceador de carga e execução sem servidor. Qualquer um deles pode interromper a resposta.

Salto	O que verificar	Sintoma quando está errado
Cliente HTTP	Timeout de leitura ou inatividade, além de timeout total da solicitação	Exceções no meio do stream apenas em respostas longas
Proxy reverso	Timeout de leitura e buffer de resposta para text/event-stream	Eventos chegam em rajadas ou o stream é interrompido
Gateway de API	Duração máxima da solicitação	Falhas no mesmo tempo decorrido em todas as execuções
Balanceador de carga	Timeout de inatividade	Queda durante pausas longas antes do primeiro evento
Função sem servidor	Tempo máximo de execução	A função termina enquanto o modelo ainda está escrevendo

Procure por cortes consistentes. Se respostas longas falham sempre após o mesmo tempo, provavelmente existe um limite rígido em algum salto. Streaming não resolve um limite absoluto de duração: nesse caso, mova o trabalho para um processo assíncrono.

Execute trabalhos longos em segundo plano

Para os trabalhos mais longos, não mantenha uma conexão HTTP ativa esperando a resposta completa.

A API de Interações suporta execução em segundo plano para tarefas de longa duração usando:

background=true

Execuções em segundo plano dependem de interações armazenadas. A documentação informa que store=false é incompatível com execução em segundo plano. Portanto, mantenha o armazenamento ativado para essas solicitações.

Fluxo recomendado:

1. Crie a interação com background=true.
2. Armazene o identificador retornado.
3. Consulte o estado e recupere o resultado conforme a documentação do Google.
4. Não presuma endpoints ou formatos de polling.
5. Grave uso, status e resultado em armazenamento durável.

Como o Google informa que novos modelos são lançados na API de Interações, planeje trabalhos longos do Argon nesse fluxo.

Limite a saída intencionalmente

O limite de 1M é um teto, não uma meta.

No generateContent, use generationConfig.maxOutputTokens para definir o máximo permitido por resposta:

{
  "generationConfig": {
    "maxOutputTokens": 60000
  }
}

No Gemini 3.8 Flash, o pensamento conta para esse limite. Em um teste limitado a 2.000 tokens, foram retornados 1.340 tokens de pensamento e 656 tokens visíveis.

Para a API de Interações, confirme o campo equivalente na documentação do Google antes de depender dele.

Defina o limite a partir do custo máximo que você aceita por chamada:

Limite de saída	Custo máximo de saída no preço padrão (US$ 20/1M)	Introdução (US$ 10/1M)
64.000	US$ 1,28	US$ 0,64
128.000	US$ 2,56	US$ 1,28
500.000	US$ 10,00	US$ 5,00
1.000.000	US$ 20,00	US$ 10,00

Uma resposta que atinge o limite pode estar incompleta. Verifique o finishReason no evento final:

MAX_TOKENS

Quando esse valor aparecer:

1. Marque o resultado como truncado.
2. Salve o ponto de continuação, se aplicável.
3. Continue em uma nova chamada ou aumente o limite apenas para esse job.
4. Evite repetir toda a geração sem necessidade.

Armazene e analise grandes saídas sem buffer

Um milhão de tokens representa vários megabytes de texto. Evite que uma única resposta esgote a memória do worker.

Use estas práticas:

• Grave fragmentos à medida que chegam em arquivo, armazenamento de objeto ou upload multipart.
• Não monte uma string gigante em memória antes de persistir o resultado.
• Preserve o arquivo parcial se a conexão cair. Uma nova tentativa cega pode regenerar e cobrar a mesma saída.
• Quando precisar de estrutura, solicite JSON Lines para processar uma linha por vez.
• Registre usageMetadata, tamanho em bytes, identificador da requisição e status, em vez de registrar corpos completos.
• Verifique limites de tamanho em colunas de banco, mensagens de fila e payloads de webhooks antes de aceitar respostas de 800K tokens.

Um padrão simples para persistência incremental é:

with open("output.txt", "a", encoding="utf-8") as output:
    for chunk in stream:
        output.write(chunk)
        output.flush()

Para JSON Lines, processe sem carregar o documento inteiro:

import json

with open("result.jsonl", encoding="utf-8") as source:
    for line in source:
        record = json.loads(line)
        process(record)

Teste no Apidog antes que o acesso seja liberado

Você pode validar a arquitetura antes de receber acesso ao Argon. Baixe o Apidog e execute três verificações.

1. Observe o stream

Envie uma requisição de streaming ao Gemini 3.8 Flash usando GEMINI_API_KEY e GEMINI_MODEL como variáveis de ambiente.

O Apidog processa respostas text/event-stream e exibe os eventos em uma linha do tempo à medida que chegam. Use isso para verificar:

• tamanho dos fragmentos;
• intervalos entre eventos;
• comportamento do proxy;
• chegada do usageMetadata final;
• existência de buffering inesperado.

2. Transmita uma resposta falsa muito mais longa

O Gemini 3.8 Flash limita a saída a 65.536 tokens. Para testar timeouts, parsers e buffers além desse limite, execute um mock SSE local no mesmo formato de evento.

# long_stream_mock.py
# SSE no formato Gemini para testes de parser e timeout com dados falsos.

import json
import time
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

EVENTS = 20000
DELAY = 0.005
CHUNK = "lorem ipsum " * 40


class Handler(BaseHTTPRequestHandler):
    def do_POST(self):
        self.rfile.read(int(self.headers.get("Content-Length", 0)))

        self.send_response(200)
        self.send_header("Content-Type", "text/event-stream")
        self.end_headers()

        for i in range(EVENTS):
            event = {
                "candidates": [
                    {
                        "content": {
                            "parts": [
                                {
                                    "text": CHUNK
                                }
                            ]
                        }
                    }
                ]
            }

            if i == EVENTS - 1:
                event["usageMetadata"] = {
                    "promptTokenCount": 1200,
                    "candidatesTokenCount": 950000,
                    "thoughtsTokenCount": 40000,
                    "totalTokenCount": 991200,
                }

            self.wfile.write(
                f"data: {json.dumps(event)}\n\n".encode()
            )
            self.wfile.flush()
            time.sleep(DELAY)


ThreadingHTTPServer(("127.0.0.1", 8787), Handler).serve_forever()

Execute o servidor:

python long_stream_mock.py

Depois, configure a URL base de um ambiente mock para:

http://127.0.0.1:8787

Envie a mesma requisição de streaming pelo ambiente mock.

Esse stream leva cerca de dois minutos — 128 segundos no teste citado — e transmite 9,6 milhões de caracteres. É suficiente para revelar:

• parser que acumula resposta inteira em memória;
• proxy que retém eventos antes de encaminhá-los;
• timeout curto de cliente;
• timeout de gateway;
• buffer inadequado para SSE.

3. Afirme as contagens de tokens

Em uma solicitação generateContent sem streaming, valide o usageMetadata.

A regra de custo deve considerar:

candidatesTokenCount + thoughtsTokenCount <= seu_limite

Também valide que o custo calculado permanece abaixo do teto definido para o job.

O guia da API Argon inclui um script de cálculo de custo pronto para uso.

Perguntas frequentes

• 1M é a janela de contexto do Gemini 4 Argon?
  
  Não. 1M é o limite de saída por resposta, acima de 64K. O Google não publicou a janela de entrada do Argon.

• Quanto custa uma resposta Argon de 1M de tokens?
  
  US$ 10 de saída nas taxas de introdução e US$ 20 no preço padrão, além da entrada. Consulte os preços do Gemini 4 Argon para mais cenários.

• Posso gerar uma resposta de 1M de tokens hoje?
  
  Não, exceto se sua organização estiver na coorte Fairwind com acesso ao Argon. Gemini 3.8 Flash e Gemini 3.1 Pro Preview limitam a saída a 65.536 tokens. A Vals AI lista 262K como saída máxima para a configuração do Argon que testou.

• Preciso fazer streaming de respostas longas do Argon?
  
  O Google não publicou orientações específicas de streaming para o Argon. Porém, uma chamada sem streaming que demora minutos fica exposta a todos os timeouts de inatividade da sua infraestrutura. Use streaming ou execução em segundo plano na API de Interações.

• Como o limite de saída do Argon se compara ao GPT-6 Astra e ao Claude Opus 5.5?
  
  Ambos limitam a saída síncrona a 128K. A Anthropic permite 300K no Batch com um cabeçalho beta. Os 1M declarados do Argon são cerca de oito vezes maiores.

Seu próximo passo

Adicione streaming e um limite explícito de saída ao seu cliente Gemini agora, usando o Gemini 3.8 Flash. Em seguida, execute o cliente contra o mock de stream longo até que nenhum componente da sua pilha interrompa a resposta.

Quando o ID do Argon for publicado:

1. atualize GEMINI_MODEL;
2. execute os mesmos testes;
3. revise limites de custo;
4. valide finishReason;
5. acompanhe o stream no Apidog.