O que é uma janela de 1M tokens? Usos do contexto longo e GPT vs Claude vs Gemini

De cara: em setembro de 2026, GPT-5.5, Claude Opus 4.8 / Sonnet 4.6 e Gemini 3.7 Flash já anunciam uma janela de cerca de um milhão de tokens. «1M tokens» não é «um milhão de caracteres chineses», e encher a janela não é o mesmo que usá-la. Os limites anunciados são próximos. Recuperação efetiva, saída máxima e degraus de preço, não. Se você trabalha com JSON, o movimento certo é recortar, validar e só então decidir quanto encher — não colar o dump inteiro.

Este texto está atualizado em 5 de setembro de 2026. Os números seguem a documentação pública: a API do gpt-5.5 da OpenAI com cerca de 1,050,000 tokens no total e 128K de saída; Opus 4.8 / Sonnet 4.6 da Anthropic com 1M padrão e 128K de saída, sem sobretaxa de contexto longo; o gemini-3.7-flash do Google com 1,048,576 de entrada / 65,536 de saída. As superfícies de produto (ChatGPT, Codex, claude.ai) costumam ser mais estreitas. Não trate uma página de marketing como o limite da API.

O que 1M tokens significa

Um token é o menor pedaço que o modelo conta e cobra — não é um caractere, nem uma palavra. Em inglês, cerca de 1 token ≈ 0.75 palavras, ou aproximadamente 4 caracteres. Em chinês, um token costuma cobrir 1–2 caracteres, dependendo do tokenizer e da pontuação. JSON é mais caro: chaves, aspas, keys repetidas e indentação consomem orçamento.

1M tokens = uma janela de contexto de cerca de um milhão de tokens. Conversão aproximada: ~750,000 palavras em inglês, ou ~500,000–800,000 caracteres chineses, ou um livro grosso até alguns médios, ou um repositório de médio porte mais a documentação. Não é «um romance de um milhão de caracteres» nem «um milhão de linhas de código». O mesmo 1M comporta quantidades muito diferentes de sinal em prosa, tabelas e JSON minificado.

A janela de contexto é o orçamento compartilhado de uma única requisição: system prompt + histórico + definições de ferramentas + resultados de ferramentas + a saída desta rodada. Modelos da classe GPT-5 também contam reasoning tokens. Uma entrada de 900K tokens mais alto esforço de raciocínio vai bater em context_length_exceeded antes de o modelo «terminar de ler». O orçamento acabou.

Em 2023 o mainstream era 4K–32K. Em 2024 o Gemini 1.5 transformou 1M em manchete. Em 2025, 200K era o padrão de faixa intermediária. Em setembro de 2026, as APIs flagship já alinharam o número de propaganda em 1M. A corrida já não é «quem é mais longo», e sim quem ainda encontra agulhas depois de 200K, e cujo cache é barato o bastante para usar todo dia.

Para que serve uma janela de contexto longa

Uma janela longa resolve ver muitos materiais numa única inferência. Não substitui um banco de dados e não é memória infinita de graça. Os trabalhos abaixo em 128K costumam exigir chunking ou RAG. Em 1M você às vezes transforma «recuperar, depois perguntar» em «carregar, depois perguntar» — se o que você carrega foi filtrado antes.

• Codificação de repositório inteiro / multiarquivo: mantenha módulos relacionados, testes e definições de interface na mesma rodada para o modelo ter menos chance de perder um arquivo. A codificação com Agent ainda trava em loops de ferramentas e feedback de testes, não no anúncio da janela — cobrimos isso em Gemini 3.8 Flash e AI coding.
• Revisão de documentos longos: contratos, filings, especificações, vários PDFs lado a lado. Bom para «encontrar o conflito entre o §47 e o Anexo B». Ruim para «colar um ano de e-mail e pedir um resumo».
• Entrada multimodal longa: o Gemini conta vídeo, áudio, imagens e texto na mesma janela. Uma hora de vídeo queima tokens rápido. 1M é cota, não um convite para enviar sem compressão.
• Agents em várias etapas: JSON de ferramentas, stacks de erro e o último patch podem ficar na conversa por um tempo. Janela maior não é motivo para reinjetar stacks crus — veja o fluxo de dados JSON do Agent.
• Alinhamento de JSON grande: OpenAPI / JSON Schema, payloads de exemplo e logs de erro de produção numa única rodada. Este é o uso de 1M com que a maioria dos leitores deste site deveria se importar — e o jeito mais fácil de estourar a fatura.
• Pular uma camada de RAG: quando o corpus é estável, limitado e você precisa de citações literais toda vez, encher o contexto pode ser mais simples que um vector store. Quando o corpus muda todo dia ou as consultas se repetem, a recuperação ainda é mais barata e mais atual.

O inverso: chat, classificação de um rótulo só, extração curta de JSON. Uma janela de 1M é desperdício. Latência, prefills e cobrança por token todos te penalizam. Tarefa curta pede modelo curto ou orçamento curto.

GPT vs Claude vs Gemini

A tabela abaixo é o que você pode colocar num documento em 5 de setembro de 2026. Os preços são as tarifas oficiais por milhão de tokens; os tetos das superfícies de produto são outra conta. O Gemini 3.8 Flash ainda não está em GA na data deste artigo — mantenha a produção no 3.7.

Como ler: os três flagships conseguem ingerir cerca de 1M. As diferenças são folga de saída, se o reasoning come a janela, se tokens além de 200K custam mais, e se o cache vale a pena.

• Você precisa de um resultado estruturado longo numa tacada só (JSON grande, um patch longo, um diff multiarquivo): GPT-5.5 e Claude 4.6/4.8 com 128K de saída têm cerca de 2× os ~64K do Gemini. O Gemini é melhor em «ler muito, escrever uma tabela».
• O mesmo system prompt + schema de ferramentas em toda chamada: o prompt cache do Claude, o Context Caching do Gemini e o cached input da OpenAI todos saem mais em conta do que pagar a entrada cheia toda vez. O JSON de tools do Agent pertence ao cache — veja Tool Calling e JSON Schema.
• Orçamento apertado, muito material, saída curta: o preço Intro do Gemini 3.7 Flash ainda é a faixa 1M mais barata dos três. Depois de 200K, meça multi-agulha nos seus próprios dados; não confie só no número da janela.
• Produto ≠ API: o GPT-5.5 no ChatGPT / Codex pode ser 400K; alguns marketplaces em nuvem ainda servem Claude em 200K. Abra a model card da superfície em que você publica antes de escrever um SLA.

Janela anunciada vs janela útil

Em 2026 o consenso é difícil de ignorar: anunciar 1M e usar 1M são trabalhos diferentes. Na recuperação multi-agulha (estilo MRCR v2: achar vários fatos espalhados num texto enorme), a acurácia costuma começar a cair depois de 128K, se divide entre 200K e 512K, e perto de 1M só poucos modelos ainda se comportam como se tivessem lido o arquivo inteiro.

Evals públicos e compilados de terceiros (os setups não são idênticos — trate como tendência, não como teste de aceite) ficam mais ou menos assim:

• GPT-5.5: um degrau acima do GPT-5.x anterior no raciocínio multi-agulha na faixa 512K–1M, e uma das APIs mais citadas quando as pessoas de fato enchem a janela. «Achar esta frase» de agulha única vai bem para os três dentro de 128K.
• Claude Opus 4.6: multi-agulha em 1M já foi reportada em torno de 76%, com uma curva mais plana. 4.7 / 4.8 inclinam mais para a calibração — recusar ou marcar incerteza em vez de inventar um lugar. Revisão de conformidade em documentos longos costuma querer a segunda.
• Gemini 3.x: ainda forte em recuperação e compreensão de documentos longos dentro de 128K; multi-agulha cai mais íngreme depois de 200K. Bom para «ler uma pilha grossa, emitir um JSON curto». Ruim para «garantir a 8ª agulha em 900K tokens de logs».

Em produção, use três faixas — não a tabela de preços:

«Lost in the middle» não sumiu quando as janelas chegaram a 1M. Coloque restrições duras no começo do system prompt e no fim da mensagem do usuário; deixe apêndices no meio. Os modelos lembram «saia JSON que corresponda ao schema» com mais frequência do que um enum enterrado no token 400,000.

JSON: encher não é validar

Uma janela de 1M é a primeira vez em que «o OpenAPI inteiro, três dias de logs de erro e um schema rascunho» cabem numa única requisição. Isso não transforma JSON ilegal em legal, e não aperta um schema frouxo. A janela é visibilidade; o contrato é forma. Já usamos essa regra em Do prompt ao Structured Output e OpenAI vs Gemini Structured Output: bloqueie tokens ilegais na decodificação com Schema, depois valide de novo após a chamada.

Encher um dump de produção de 800K tokens costuma falhar por motivos que não são «a janela era pequena demais»: keys repetidas desperdiçam orçamento, campos do meio são descartados, comprimentos de array são contados errado, a saída corta no teto de 64K/128K, e você paga a entrada cheia. A ordem é recortar → validar → só então alimentar.

{
  "name": "longContextPack",
  "description": "Pack sent into a 1M window: only validated, trimmed JSON",
  "parameters": {
    "type": "object",
    "additionalProperties": false,
    "properties": {
      "task": { "type": "string", "enum": ["align_fields", "diff_versions", "extract_errors"] },
      "schemaId": { "type": "string", "description": "Stable schema id — do not paste a giant schema inline" },
      "focusPaths": {
        "type": "array",
        "minItems": 1,
        "maxItems": 32,
        "items": { "type": "string", "description": "JSONPath, e.g. $.paths./v2/orders.post" }
      },
      "payload": { "type": "object", "description": "Already syntax-checked and size-trimmed — not a raw log string" },
      "tokenBudget": { "type": "integer", "minimum": 1000, "maximum": 1000000 }
    },
    "required": ["task", "schemaId", "focusPaths", "payload", "tokenBudget"]
  }
}

Jogue esse pacote na caixa de ferramentas JSON para uma checagem local de sintaxe, extraia focusPaths com JSONPath e faça Diff de duas versões do payload. O modelo deve ver um objeto recortado, não um arquivo .json de 20MB. Troque GPT / Claude / Gemini mudando a string do modelo. Os nomes de campo do pacote não devem mudar.

O que fazer agora

1. Conte tokens antes de encher: estime system, tools, histórico e anexos em separado. Reserve reasoning no GPT-5.5; conte páginas de vídeo / PDF no Gemini. Se passou do orçamento, corte — não aposte em «ainda deve caber».
2. Faça cache de prefixos repetidos: system + tools são quase iguais em toda chamada, então pertencem ao prompt cache / Context Caching. A primeira fatura de janela 1M é uma conta de entrada; depois dos cache hits, a janela longa fica usável no dia a dia.
3. Trave a saída com Structured Output, não com «por favor devolva JSON»: response_format.json_schema da OpenAI, responseMimeType + responseJsonSchema do Gemini, tools ou prefills do Claude. Janela mais longa ainda inventa um campo e deixa cair um required se o prompt for frouxo.
4. Passou da faixa que você mediu, recupere — não enfie: se o seu próprio multi-agulha falhou em 256K, não trate 700K de logs como compreensão de texto completo. JSONPath em códigos de erro e timestamps é mais barato do que deixar o modelo nadar.
5. Divida as respostas no teto de saída: ~64K no Gemini, ~128K no GPT/Claude. Um relatório JSON de 200K é fatias mais um schema por fatia, não uma completion heroica.
6. Rode fixtures locais antes de bater na API: o mesmo payload por validação JSON e Diff no navegador. Nada é enviado. É o mesmo hábito de checar um contrato REST antes do lançamento.

Perguntas frequentes

Conclusão

1M tokens é o anúncio das APIs flagship de 2026 que GPT-5.5, Claude 4.6/4.8 e Gemini 3.7 podem todos imprimir numa página de limites. Serve quando uma inferência precisa ver um repositório, um documento longo ou um pacote JSON recortado. Não é memória de graça, e encher não é entender. Janelas úteis costumam ficar entre 128K e 500K; trate um 1M cheio como capacidade, não como compreensão. Tetos de saída, se o reasoning consome a janela, e se tokens além de 200K custam mais são os campos reais de escolha.

O trabalho não é correr atrás do próximo rumor de «2M». É empacotar o que você envia para sobreviver a uma checagem de schema: JSONPath para recortar caminhos, Diff para comparar versões, validar, depois chamar a API. Este site já cobre Structured Output e Tool Calling; este artigo só acrescenta a leitura da janela de contexto.