Janela de 1.050.000 tokens do GPT-6 Sol: dá para jogar o repositório inteiro no prompt?

Colar o repositório inteiro no prompt sempre foi aquele plano preguiçoso que não cabia na janela

Agora cabe…

Em 22/09/2026 a OpenAI anunciou o GPT-6 Sol e o GPT-6 Luna, e a manchete pra quem escreve código é uma só: 1.050.000 tokens de contexto. Aí vem a pergunta que tu já fez na cabeça antes de terminar de ler o anúncio: dá pra jogar o projeto todo lá dentro e deixar o modelo se virar? Dá, tecnicamente. A questão é se isso te dá um resultado melhor ou só uma fatura maior

O que a OpenAI anunciou no GPT-6 Sol e Luna

O anúncio oficial se chama Introducing GPT-6 Sol and Luna e saiu em 22/09/2026

O Sol é o irmão voltado pra código: a OpenAI posiciona ele como "built for complex coding and agentic workflows", com model ID gpt-6-sol. Ou seja, é o modelo que ela quer ver rodando dentro de agente, dentro de CLI, dentro do teu loop de tarefa, não só respondendo pergunta solta no chat

Os números da página do modelo são estes:

• 1.050.000 tokens de contexto
• até 128.000 tokens de saída
• corte de conhecimento em 20/04/2026

E por que o corte de conhecimento importa aqui? Porque ele é o limite do que o modelo "sabe de cabeça". Tudo que a tua stack lançou depois disso precisa entrar no contexto, e é exatamente esse tipo de coisa que faz um prompt de código inflar rápido: changelog, doc de lib nova, migration de framework

Vale lembrar que Sol e Luna vêm depois do GPT-6 Astra, lançado em 03/09/2026, que tem exatamente a mesma janela de contexto de 1.050.000 tokens e 128.000 de saída. A diferença entre eles não está no tamanho do balde, e sim no preço por litro

Formação Recomendada

Formação Claude Code

Domine Claude Code do absoluto zero até o avançado

• 120 aulas
• 4 projetos
• 9h 45min

Conhecer formação

Quanto custa usar a janela inteira: preço padrão x contexto longo

Aqui mora a pegadinha que muita gente descobre depois, olhando o billing

O preço padrão de API do GPT-6 Sol é US$ 2,00 por 1M de tokens de entrada e US$ 10,00 por 1M de tokens de saída. Só que prompts acima de 272K tokens de entrada caem na tabela de contexto longo

E atenção nisso, é o detalhe que dói: a sobretaxa vale para a requisição inteira, não só para a parte excedente. A regra é 2x nas taxas de input e de cache e 1,5x no output, aplicada no request todo. Não existe aquele conforto mental de "passei 10K do limite, pago a mais só nos 10K"

n/d aqui é só porque os valores de cache do Astra não entram nesta comparação, o ponto da coluna é mostrar que mesma janela não significa mesmo preço

Repara no que a tabela conta: a janela de contexto do GPT-6 Sol é idêntica à do Astra, e mesmo assim o Sol entra por US$ 2,00 na entrada padrão contra US$ 10,00 do Astra. A escolha entre eles não é de capacidade de leitura, é de bolso e de tipo de tarefa

E tem um detalhe bom: esse corte de 50% no preço de API de Sol e Luna frente à precificação promocional do GPT-5.6 é permanente. Porta-voz da OpenAI confirmou ao VentureBeat que não é preço introdutório que vai subir daqui a três meses. Dá pra planejar em cima disso

O que a janela grande resolve de verdade (e o que continua com você)

Bora separar as coisas, porque tem muito hype misturando dois problemas diferentes

O que 1.050.000 tokens realmente resolvem:

• Fatiar arquivo na mão: aquele arquivo legado de milhares de linhas agora entra inteiro, sem tu ter que picotar e explicar que "a parte 2 continua a parte 1"
• Perder o fio da sessão longa: conversa comprida com várias idas e vindas cabe sem o modelo esquecer o que ficou combinado lá atrás
• Cruzar arquivos distantes: o model consegue ver o controller, o service e o teste ao mesmo tempo, em vez de adivinhar a assinatura da função pelo nome

Isso é real e é MUITO bom. Quem já fez refactor grande sabe a dor de ficar copiando pedacinho

Agora, o que continua sendo responsabilidade tua:

1. Seleção de arquivos: decidir o que o modelo precisa ler pra tomar a decisão. Repositório inteiro inclui node_modules de ideia velha, doc desatualizada, feature morta e aquele script que ninguém tem coragem de deletar
2. Ordem do contexto: o que vem primeiro e o que vem por último muda preço e muda o foco (já já explico o porquê no cache)
3. Ruído: tudo que tu joga ali compete pela atenção do modelo. Contexto contraditório é pior que contexto faltando, porque ele te responde com confiança em cima do arquivo errado

A OpenAI afirma que o GPT-6 Sol comete cerca de metade dos erros do GPT-5.6 Sol. É uma melhora expressiva, e é exatamente por isso que eu insisto no ponto: menos erro do modelo não é o mesmo que menos erro do teu prompt. Se tu entrega o repo todo e ele conserta o UserService que não é mais usado, o modelo acertou a tarefa que tu deu, não a que tu queria

É como contratar um dev sênior muito bom e largar na mesa dele a pasta inteira da empresa sem dizer qual é o bug. Ele vai ler tudo, e vai te cobrar por isso

Quando vale encher o contexto e quando é melhor selecionar arquivos

O critério é sempre o mesmo, e cabe numa frase: o que o modelo precisa LER pra decidir, não o que existe no repositório

Casos em que encher o contexto faz sentido:

• Auditoria ampla: "onde a gente valida permissão neste projeto?" é uma pergunta que só tem resposta boa se ele varrer bastante coisa
• Leitura de arquitetura: entrar num projeto novo e pedir um mapa de como as camadas conversam
• Caçar padrão espalhado: uso inconsistente de uma lib, tratamento de erro que muda de arquivo pra arquivo, esse tipo de coisa que só aparece no agregado
• Migração que atravessa o projeto: quando a mudança em um lugar quebra outro que tu nem lembra que existe

Casos em que selecionar arquivo ganha fácil:

• Correção de bug pontual: tu tem o stack trace. O stack trace já te disse quais arquivos importam. Manda esses, mais o teste, mais o model envolvido
• Refactor local: extrair método, renomear, quebrar uma função grande. O contexto necessário é o arquivo e quem chama ele
• Revisão de PR: o diff já É a seleção. Mandar o repo inteiro junto com o diff é pagar dobrado pra diluir a atenção do modelo no que interessa
• Tarefa repetida em loop: agente rodando muitas vezes com prompt gigante é a receita clássica de fatura assustadora

Tome cuidado com a armadilha do "na dúvida manda tudo". Na dúvida, o correto é descobrir de qual arquivo tu tem dúvida… 😀

Por que o cache não te salva quando você joga o repositório todo

O sintoma é clássico: "mas eu mando o mesmo contexto toda vez, o cache não deveria baratear isso?"

E aí vem a conta alta do mesmo jeito

A causa está em como o prompt caching da OpenAI funciona: por correspondência exata de prefixo. O cache só é aproveitado se o começo do prompt for idêntico ao de antes. Ele funciona automaticamente a partir de 1.024 tokens, com acertos em incrementos de 128 tokens

Quer dizer: mudança pequena nos tokens iniciais invalida a correspondência. Colocou timestamp no topo? Invalidou. Mudou a ordem em que teu script lê os arquivos? Invalidou. Injetou o nome do usuário ou o ID da sessão antes do bloco de código? Invalidou

E o dinheiro em jogo não é pouco. Tokens de entrada cacheados custam 10% da taxa de entrada não cacheada, enquanto a escrita de cache é cobrada a 1,25x essa taxa. Em contexto longo isso vira US$ 0,40 por 1M de entrada cacheada contra US$ 5,00 por 1M de escrita de cache. Cada miss te faz pagar a escrita de novo, no valor cheio de contexto longo

A solução é a que a própria documentação de prompt caching orienta: conteúdo durável no início, conteúdo volátil no fim

Na prática, a ordem do teu prompt fica assim:

[1] instruções do sistema, estáveis
[2] arquivos do projeto que não mudam entre as chamadas
[3] documentação e convenções do time
---- daqui pra baixo muda a cada request ----
[4] dados de sessão, valores dinâmicos
[5] a pergunta / tarefa do usuário

Como prevenir o problema antes dele acontecer:

1. Congele o topo do prompt: se a ordem dos arquivos é gerada por um glob, ordene de forma determinística. Glob que devolve ordem diferente entre execuções é um destruidor de cache silencioso
2. Tire variável dinâmica do início: data, hora, contador, ID de request, tudo isso vai pro fim
3. Fique de olho no limite de 272K: se o teu prompt fixo já vive perto dessa marca, qualquer arquivo a mais joga a requisição inteira na tabela de contexto longo, e a sobretaxa pega o request todo
4. Separe prompt estável de prompt experimental: se tu está iterando na instrução, tu está reescrevendo o prefixo a cada teste, e cache nenhum vai te ajudar nessa fase

Vale trocar seu modelo de código pelo GPT-6 Sol?

Vamos aos números do anúncio, que é o que dá pra checar hoje

No DeepSWE v1.1, benchmark de engenharia de software em repositórios reais, o GPT-6 Sol fez 68,8% em max effort. Isso é 1,1 ponto percentual abaixo do melhor resultado do Claude Fable 5 na avaliação (69,9% em xhigh effort), com custo por tarefa cerca de 80% menor

No FrontierCode 1.1, foram 49,3% em esforço máximo, a US$ 2,14 por tarefa

Lê de novo aquele "1,1 ponto percentual" ao lado de "80% menor". É aí que a conversa fica interessante, porque empate técnico com um terço do custo por tarefa resolvida muda o cálculo de quem roda agente o dia inteiro. Esse é o tipo de comparação que vale fazer com calma, olhando custo por tarefa resolvida em vez de só a coluna de percentual do benchmark

Sobre disponibilidade fora da API: no GitHub Copilot, o GPT-6 Sol está disponível para Copilot Pro+, Max, Business e Enterprise, e o GPT-6 Luna para Copilot Pro, Pro+, Max, Business e Enterprise. Os dois são cobrados por usage-based billing, então lá também vale a lógica de não desperdiçar contexto

Meu veredito, sem drama: se tu usa modelo de código em volume, o Sol merece entrar na rotação por causa da combinação de resultado e preço permanente. Se tu usa pontualmente e já tem um fluxo afiado com outro modelo, a diferença de 1,1 ponto não é motivo pra migrar às pressas. Troca de modelo tem custo de adaptação de prompt que nenhum benchmark mede

Conclusão

Janela de contexto é orçamento, não estratégia

Os 1.050.000 tokens do GPT-6 Sol tiram do teu caminho o problema de "não cabe". Eles não tiram o problema de "o que importa aqui", e esse continua sendo teu, com ou sem modelo bom. Contexto grande sem curadoria é ruído caro, ainda mais com a sobretaxa de contexto longo pegando a requisição inteira acima de 272K

O próximo passo prático é medir antes de despejar: pega as últimas cinco tarefas de código que tu resolveu e pergunta quantos arquivos realmente precisavam estar ali pra decisão ser tomada. Na maioria das vezes a resposta vai ser bem menor do que o repositório, e aí tu decide pelo dado e não pelo impulso

E se tu for testar o despejo total mesmo assim, faz o teste com a ordem do prompt organizada, durável em cima e volátil embaixo. Pelo menos a fatura agradece 😀

Até o próximo post!