Context window: o motivo real de a IA 'esquecer' o que você disse

Quando um modelo de IA "esquece" algo que você disse cinco mensagens atrás, o problema quase nunca é falta de inteligência — é a context window. E entender como essa janela funciona muda completamente a forma como você trabalha com esses modelos: para de parecer mágica caprichosa e vira uma restrição de engenharia que dá pra contornar.

O modelo não tem um baú de memórias de onde puxa lembranças. Ele tem uma janela — uma quantidade fixa de texto que consegue enxergar de uma vez — e só. Tudo que importa acontece dentro dela. O que escorrega pra fora deixa de existir. Não é que o modelo "guardou e não achou": é que aquilo simplesmente não está mais na frente dele.

O que é, em tokens

Context window é a quantidade de texto que o modelo consegue "ver" ao gerar uma resposta. A unidade não é palavra nem caractere: é token, que é um pedaço de palavra. Palavras comuns costumam ser um token só; palavras longas, raras ou em outro idioma se quebram em vários. Uma regra de bolso grosseira para português e inglês é algo em torno de um token para cada três ou quatro caracteres — mas isso varia, e o próprio jeito de tokenizar difere entre modelos.

O ponto importante é o que entra nessa conta. Não é só a sua última pergunta. A janela inclui tudo:

As instruções de sistema (o "personagem" e as regras que o modelo recebeu antes de você chegar).
Todo o histórico da conversa — suas mensagens e as respostas anteriores do modelo.
Qualquer documento, código ou arquivo que você colou ou anexou.
E o espaço reservado para a resposta que ele ainda vai gerar.

Cada nova rodada de conversa empilha mais tokens nessa pilha. A janela é fixa; a conversa cresce. Quando a soma passa do limite, o começo é descartado para caber o resto. É aí que a IA "esquece": aquela instrução que você deu lá no início escorregou pra fora da janela. Não foi apagada da memória — ela nunca esteve numa memória, estava na janela, e a janela andou pra frente.

A analogia que funciona é a de uma mesa de trabalho. Não importa quantos arquivos existam no mundo: só cabe na mesa o que cabe na mesa. Para colocar uma folha nova, alguma coisa sai da borda. O modelo trabalha exclusivamente com o que está sobre a mesa naquele instante.

"Cabe na janela" não é a mesma coisa que "é usado bem"

Aqui está a parte que quase ninguém conta. Modelos atuais operam com janelas grandes — na casa de centenas de milhares de tokens, o suficiente para um livro inteiro ou uma base de código considerável. A reação natural é: "ótimo, então é só jogar tudo lá dentro". E aí você descobre que não é bem assim.

Janela grande resolve o problema de caber. Não resolve o problema de ser usado bem. São coisas diferentes.

O modelo não distribui atenção igualmente por toda a janela. Na prática, o conteúdo no início e no fim tende a receber mais peso do que o conteúdo enterrado no meio. É o efeito que costumam chamar de "perder o meio" (lost in the middle): você cola um documento de sessenta páginas, faz uma pergunta cuja resposta está na página trinta, e o modelo responde como se aquilo não estivesse lá — porque, em termos de atenção efetiva, quase não estava.

Pense num relatório longo que alguém te manda lendo por cima. As primeiras páginas você lê com cuidado, as últimas também porque quer chegar na conclusão, e as do meio você folheia. O detalhe crítico que estava enterrado na página trinta escapa. O modelo faz algo parecido: quanto mais entulhada a janela, mais difícil para qualquer trecho específico se destacar.

A consequência prática é contraintuitiva: encher a janela pode piorar a resposta. Não porque não coube, mas porque o sinal que importava ficou diluído em ruído. Mais contexto nem sempre é mais contexto útil.

Cada token tem um custo — em dinheiro e em tempo

Existe ainda um motivo bem menos filosófico para não entupir a janela: sai caro e sai lento.

Modelos cobram, quase sempre, por token — tanto os que entram (o seu prompt e o histórico) quanto os que saem (a resposta). E o custo de entrada não é pago uma vez só. A cada nova mensagem, a conversa inteira é reenviada para o modelo, porque ele não guarda estado entre uma chamada e outra. Isso significa que uma conversa longa reprocessa o histórico acumulado repetidamente. A décima mensagem de uma conversa longa custa muito mais que a primeira, mesmo que você tenha digitado uma frase curta — porque, por baixo, foram reenviados também os nove turnos anteriores.

E não é só dinheiro. Mais tokens na janela significam mais lentidão: o modelo tem mais coisa para processar antes de começar a responder, e você sente isso como demora. Uma janela lotada é um imposto que você paga em toda rodada seguinte, em reais e em segundos.

Como trabalhar com o limite

A boa notícia: nada disso é um beco sem saída. Dá para trabalhar com a janela em vez de brigar contra ela. Algumas práticas que fazem diferença real:

Resuma e recomeçe. Quando uma conversa fica longa e começa a divagar, não deixe ela apodrecer. Peça um resumo do que foi decidido até ali, abra uma conversa nova e cole só o resumo. Você troca um histórico enorme e diluído por um punhado de tokens densos e relevantes. Na prática, é você limpando a mesa e deixando em cima só as folhas que importam.
Separe contexto persistente de contexto de tarefa. Instruções que valem sempre — convenções de código, tom de voz, regras do projeto — não deveriam ser redigitadas a cada prompt. Coloque isso num lugar fixo (um arquivo de configuração, um bloco de instruções de sistema, um CLAUDE.md da vida). Contexto de tarefa é o que muda a cada pedido; contexto persistente é o pano de fundo estável. Misturar os dois desperdiça janela e faz você repetir a mesma coisa dez vezes.
Reforce o essencial perto do fim. Já que o fim da janela pesa mais, use isso a seu favor. Se há uma instrução que o modelo não pode ignorar, ela vai melhor perto da sua última mensagem do que perdida lá no início da conversa. "Lembra que a resposta precisa ser em português e em tópicos" repetido no momento certo vale mais que a mesma frase enterrada vinte turnos atrás.
Corte o que não serve. Não cole o log inteiro se o erro está em três linhas. Não anexe o arquivo de mil linhas se a pergunta é sobre uma função. Curadoria de contexto é uma habilidade: quanto mais limpo o que entra, mais afiada a atenção do modelo sobre o que importa — e mais barato e rápido o resultado.

O ponto prático

Se a IA "esqueceu" algo, a pergunta certa não é "por que ela é burra". É outra, mais útil: isso ainda está dentro da janela — e está posicionado de um jeito que o modelo consegue usar bem?

Na maioria das vezes em que o modelo parece perder o fio, a explicação é uma dessas duas: ou a informação escorregou pra fora da janela, ou ela está lá dentro mas afogada no meio de um mar de contexto. As duas têm conserto, e nenhuma delas exige um modelo mais inteligente — exige você tratando a janela de contexto como o recurso escasso que ela é. Menos entulho, mais curadoria, e o essencial sempre à vista.