Seu agente lembra. Esse é o problema.

Passamos um ano ensinando agentes de codificação a lembrar das coisas. Lembrar acabou sendo a parte fácil. A parte difícil é saber quais dessas memórias ainda são verdadeiras.

Aqui está a falha que finalmente me pegou.

Um palpite, promovido a um fato

Eu disse ao Cursor que meu projeto havia mudado de npm para bun. Mais tarde, no Claude Code, o agente executou npm install com confiança e passou um tempo depurando uma construção que nunca funcionaria. A crença de "usamos npm" sobreviveu à verdade — e nada a sinalizou, porque para o agente parecia exatamente como qualquer outro fato na memória.

Mesma forma que o clássico: "usamos Jest" sobrevive a uma migração para Vitest, e três sessões depois um agente está alegremente escrevendo testes Jest para um repositório que não tem mais Jest.

Nenhum desses é um problema de esquecimento. O agente lembrou bem. Ele lembrou de algo que costumava ser verdade e tratou isso como se ainda fosse.

Sincronização não é a solução

A maioria das ferramentas de "memória de IA" são realmente ferramentas de sincronização: capturam o que aconteceu em uma ferramenta, tornam disponível na próxima. Isso é genuinamente útil — mas torna a situação acima pior, porque agora seu palpite desatualizado viaja com você.

E as memórias perigosas não são as obscuras. Elas são as que são referenciadas constantemente — seu stack, suas convenções, seu "sempre faça X". Leituras de alta frequência parecem de alta confiança, então essas são re-injetadas em cada nova sessão primeiro. Se uma delas estiver errada, a pontuação de importância a protegerá carinhosamente.

Então a pergunta em que fiquei preso deixou de ser o que o agente deve lembrar. Tornou-se o que o agente realmente ganhou o direito de chamar de verdadeiro.

Tratar a memória como um problema de confiança

O modelo em que cheguei: nada que um agente escreve é confiável por padrão.

Cada fato que um agente registra é considerado não verificado — não importa quão confiante parecia ao escrevê-lo. Ele só se torna "confirmado" quando algo fora do agente diz isso:

• Eu assino embaixo (uma decisão humana), ou
• um sinal forte faz isso — um teste bem-sucedido, um resultado de comando, ou um âncora de repositório (uma dependência, um arquivo que realmente existe).

A parte que mais importa: quando uma âncora quebra — a dependência desaparece, o arquivo se move — o fato não fica em um temporizador de obsolescência esperando para expirar. Ele se reverte imediatamente a um palpite. A verdade se foi, então a confiança vai junto.

O que significa que o agente nunca corrige seu próprio dever de casa. Uma inferência errada confiante e uma correta começam a vida idênticas — ambas não verificadas — e apenas uma delas ganha o status de "fato". Você não precisa pegar a mentira. Você apenas nunca lhe entrega o distintivo.

As partes pouco glamourosas (onde o tempo realmente foi gasto)

Se você construir um desses, as ideias de design interessantes são cerca de 10% do trabalho. O restante é a parte chata que decide se você pode confiar na coisa:

• Gravações atômicas. O que me pegou não foi uma gravação perdida — foi um arquivo meio escrito após uma falha no meio da gravação, que é lido como válido até que de repente não seja. Grave em um arquivo temporário, renomeie sobre o alvo, mantenha uma cópia do último bom conhecido para que uma gravação corrompida retorne em vez de derrubar todo o armazenamento.
• Redação antes da persistência. A memória é um lugar fantástico para armazenar acidentalmente um segredo para sempre. Qualquer coisa buscada, registrada ou colada é sanitizada antes de aterrissar.
• Proveniência em cada registro. Ferramenta de origem, quando foi escrito, como ganhou confiança. Limpeza e decisões de confiança são basicamente impossíveis depois sem isso.

Nada disso é glamouroso. Tudo isso é a diferença entre uma camada de memória na qual você pode confiar e um arquivo JSON que ocasionalmente mente para você.

Sendo justo sobre isso

A confiança não é o único eixo. A poda de importância/recência — manter o que importa, descartar o ruído — é uma ideia real e útil, e muitas boas ferramentas de memória começam com isso. Eu apenas acho que responde a uma pergunta diferente (o que vale a pena manter) do que a que continuava me queimando (o que é realmente verdadeiro). Elas são complementares; eu gostaria de ter ambas.

Construindo isso em público

Eu empacotei isso em piia-engram — uma camada de memória local-primeiro e cega ao conteúdo para clientes MCP (Claude Code, Cursor, Codex). Código aberto, pip install piia-engram. É local-primeiro principalmente porque a resposta mais limpa para "minha memória é privada?" é "nada saiu da sua máquina em primeiro lugar."

Mas a ferramenta é honestamente secundária à ideia. Se você está construindo ou usando memória entre ferramentas, eu realmente gostaria de saber: como você decide o que seu agente pode confiar? Importância? Recência? Proveniência? Algo completamente diferente?

Me diga onde isso quebra.

Construindo em público. Local-primeiro. O palpite de uma IA não é um fato até que algo prove isso.