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, 1M de tokens, é seu limite de saída, não sua janela de contexto. O Google afirma que uma única resposta do Argon pode atingir 1 milhão de tokens, aproximadamente 16 vezes o limite anterior de 64K, e não publicou a janela de entrada do Argon. Também não há nada a chamar ainda: o Argon está disponível hoje apenas para defensores do Fairwind Program, com clientes de API pagantes a seguir, assim que o Google abrir o acesso (consulte o guia de data de lançamento e acesso).

Uma resposta tão longa quebra três premissas nas quais a maioria das pilhas de API se baseia: uma chamada termina em segundos, o corpo cabe na memória e uma solicitação tem um custo pequeno e previsível. Este guia abrange o custo de uma resposta máxima, streaming, timeouts, limites de saída, armazenamento e como testar tudo isso no Apidog antes que o acesso chegue. Para uma visão geral do modelo, consulte o que é o Gemini 4 Argon; para formatos de solicitação, consulte o guia da API Gemini 4 Argon.

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

Várias páginas que classificam o Argon descrevem o número de 1M como uma janela de contexto, e uma manchete o chama de “janela de contexto 16 vezes maior”. Isso está errado. A publicação de lançamento do Google afirma que ele expandiu “o limite de tokens de saída do modelo para um recorde da indústria de 1M de tokens”. Esse 64K corresponde ao limite de saída de 65.536 tokens no Gemini 3.1 Pro Preview, o modelo Pro top anterior do Google.

A entrada é um número separado que o Google não forneceu. Sua avaliação de contexto longo, descrita na metodologia de avaliação, usou prompts entre 256K e 1M de tokens. Isso é um subconjunto de benchmark, não uma especificação. Há uma ressalva no lado da saída também: a Vals AI lista uma saída máxima de 262K para a configuração do Argon que testou. O Google diz que o limite do modelo é de 1M; pelo menos um avaliador terceirizado viu um limite inferior no endpoint que usou.

Todos os concorrentes limitam a saída síncrona a 128K, então o limite declarado do Argon é cerca de 8 vezes o deles. A razão do Google é a profundidade do raciocínio: com margem, o modelo pode “gerar centenas de milhares de tokens em uma única trajetória” e resolver problemas difíceis em uma única passagem. Para ver como outros fornecedores lidam com execuções longas, consulte 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

Preço máximo primeiro. A saída é cobrada a $10 por 1M de tokens durante o período de introdução do Argon e $20 depois, então uma resposta de comprimento total custa:

• Introdução: 1.000.000 x $10/1M = $10,00 de saída
• Padrão: 1.000.000 x $20/1M = $20,00 de saída

A entrada vem por cima. Um prompt de 200.000 tokens adiciona 200.000 x $2/1M = $0,40 nas taxas de introdução ou $0,80 nas taxas padrão, então uma única chamada máxima custa $10,40 ou $20,80. Um trabalho noturno que dispara 100 dessas chamadas custa $1.040 nas taxas de introdução.

O pensamento torna isso mais difícil de ver. Nos modelos Gemini atuais, os tokens de pensamento são cobrados como saída; o Google não disse se o Argon segue essa regra ou se o pensamento conta para o limite de 1M. De qualquer forma, uma resposta visível curta ainda pode gerar uma grande cobrança de saída. O guia de preços do Gemini 4 Argon apresenta mais cenários, incluindo entrada em cache com 95% de desconto.

Por que o streaming é obrigatório

Uma chamada sem streaming não retorna nada até que toda a resposta seja concluída. Com centenas de milhares de tokens, essa é uma conexão silenciosa longa, e os timeouts de inatividade em sua pilha podem fechá-la antes que o primeiro byte chegue.

Transmita em vez disso. Em generateContent, troque o método por :streamGenerateContent?alt=sse e o Google envia eventos server-sent, um pedaço de candidatos parcial por evento. Leia cada evento à medida que ele chega e grave-o; não colete o corpo primeiro. Isso funciona hoje no Gemini 3.8 Flash, com o modelo em uma variável porque o Google não publicou o ID do modelo Argon (a configuração está em nosso guia da API Gemini 3.8 Flash):

import json, os, 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 r, \
        open("response.txt", "a", encoding="utf-8") as out:
    r.raise_for_status()
    for line in r.iter_lines(decode_unicode=True):
        if not line or not line.startswith("data:"):
            continue
        event = json.loads(line[5:])
        for cand in event.get("candidates", []):
            for part in cand.get("content", {}).get("parts", []):
                out.write(part.get("text", ""))
        out.flush()
        usage = event.get("usageMetadata", usage)
print(usage)

timeout=(10, 120) define um timeout de conexão de 10 segundos e um timeout de leitura de 120 segundos. Em requests, o timeout de leitura é a maior lacuna entre bytes, não a duração total, então um stream que continua enviando pode ser executado pelo tempo que for necessário. Cada pedaço vai para o disco à medida que chega. No 3.8 Flash, cada evento carrega um usageMetadata contínuo, então o último fornece as contagens finais de tokens para registrar e cobrar.

Timeouts em cada salto

Seu cliente é um salto. Um stream longo também cruza um proxy reverso, um gateway de API, um balanceador de carga e talvez um tempo de execução sem servidor, e qualquer um deles pode encerrar a resposta precocemente:

Observe um corte fixo. Se respostas longas sempre falham no mesmo tempo decorrido, algum salto tem um limite de duração rígido que o streaming não pode corrigir, e esse trabalho precisa sair do caminho da solicitação.

Execute trabalhos longos em segundo plano

Para os trabalhos mais longos, retire o trabalho de uma conexão ativa. A API de Interações suporta execução em segundo plano para tarefas de longa duração usando background=true. As execuções em segundo plano dependem de interações armazenadas: a documentação diz que store=false é incompatível com a execução em segundo plano, então mantenha o armazenamento ativado para essas solicitações. Para recuperar uma interação em segundo plano concluída, siga a documentação do Google; não tente adivinhar os endpoints de polling. Como o Google afirma que novos modelos são lançados na API de Interações, planeje que os trabalhos longos do Argon sejam executados lá.

Limite a saída intencionalmente

O limite de 1M é um teto, não um objetivo. Em generateContent, generationConfig.maxOutputTokens limita cada resposta; o exemplo de streaming define 60.000. No 3.8 Flash, o pensamento conta para esse limite: nossa execução de teste limitada a 2.000 retornou 1.340 tokens de pensamento e 656 visíveis. Para a API de Interações, confirme o campo de limite de saída na documentação do Google antes de depender dele. Então escolha o limite com base no custo que você aceitará por chamada:

Uma resposta que atinge o limite para cedo, então trate-a como incompleta. Verifique o finishReason do evento final: MAX_TOKENS significa que o limite o interrompeu. Em seguida, continue em uma nova rodada ou aumente o limite para esse trabalho específico.

Armazene e analise grandes saídas sem buffer

Um milhão de tokens são megabytes de texto por resposta. Algumas regras impedem que isso derrube um worker:

• Escreva os pedaços à medida que chegam, para um arquivo ou upload de objeto multipart, em vez de construir uma única string na memória.
• Mantenha o arquivo parcial se a conexão cair. Uma nova tentativa cega do zero gera e cobra a saída novamente.
• Peça JSON Lines quando precisar de estrutura, para que cada linha seja analisada por si só, em vez de esperar um documento gigante fechar.
• Registre usageMetadata e uma contagem de bytes, não corpos completos.
• Verifique os limites de coluna e tamanho de mensagem em seu banco de dados e fila antes que uma resposta de 800K tokens os atinja.

Teste no Apidog antes que o acesso seja liberado

Você pode ensaiar tudo isso contra um substituto. Baixe o Apidog e faça três verificações.

Observe o stream. Envie a solicitação de streaming contra o 3.8 Flash com GEMINI_API_KEY e GEMINI_MODEL como variáveis de ambiente. O Apidog analisa as respostas text/event-stream e mostra cada evento em sua visualização de linha do tempo à medida que chega, para que você possa ver os tamanhos dos pedaços, as lacunas e o usageMetadata final.

Transmita uma resposta falsa muito mais longa. A saída real do 3.8 Flash atinge no máximo 65.536 tokens, então execute um mock local que transmita muito mais no mesmo formato de evento:

# long_stream_mock.py: SSE em formato Gemini para testes de parser e timeout (dados falsos)
import json, time
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

EVENTS, DELAY, CHUNK = 20000, 0.005, "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:  # contagens falsas dimensionadas como uma resposta quase máxima
                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()

Aponte a URL base de um ambiente “mock” para http://127.0.0.1:8787 e envie a mesma solicitação de streaming através dele. O stream é executado por cerca de dois minutos (128 segundos em nosso teste) e carrega 9,6 milhões de caracteres de texto, o suficiente para expor um parser com buffer, um proxy que retém eventos ou um timeout definido muito curto.

Afirme sobre as contagens de tokens. Em uma solicitação generateContent sem streaming, afirme que candidatesTokenCount mais thoughtsTokenCount em usageMetadata permanece igual ou abaixo do seu limite e que o custo calculado permanece abaixo do seu teto nos preços do Argon. O guia da API Argon possui um script de custo pronto.

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? $10 de saída nas taxas de introdução e $20 no padrão, mais entrada. Consulte preços do Gemini 4 Argon para mais cenários.
• Posso gerar uma resposta de 1M de tokens hoje? Não, a menos que sua organização esteja na coorte Fairwind com acesso ao Argon. O Gemini 3.8 Flash e o 3.1 Pro Preview limitam a saída a 65.536 tokens, e a Vals AI lista uma saída máxima de 262K para a configuração do Argon que testou.
• Preciso fazer streaming de respostas longas do Argon? O Google não publicou orientações de streaming para o Argon, mas uma chamada sem streaming que leva minutos está exposta a todos os timeouts de inatividade em sua pilha. Faça o streaming ou use a 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 8 vezes isso.

Seu próximo passo

Adicione streaming e um limite de saída ao seu cliente Gemini agora, no 3.8 Flash, e execute-o contra o stream mock longo até que nada em sua pilha o interrompa. Quando o ID do Argon for lançado, altere GEMINI_MODEL e execute novamente os mesmos testes no Apidog.