O Guia Definitivo: Como Adicionar 'Memória Infinita' ao Codex em Apenas 3 Minutos

Você conhece o mecanismo para adicionar um "segundo cérebro" ao Codex para que o contexto permaneça mesmo se a conversa for interrompida? Seu nome é Agentmemory. Resumi tudo, desde o procedimento de instalação e configuração até as armadilhas comuns. Este artigo é leitura obrigatória para quem acha tedioso explicar a mesma coisa toda vez e para quem não quer desperdiçar tokens.

Toda manhã, eu inicio o Claude Code e digito "Continuar de ontem", só para receber "Por favor, informe o conteúdo da sessão anterior." Esse é um fenômeno que acontece quase todos os dias.

No momento em que uma sessão é interrompida, o contexto do projeto é reiniciado. Embora as informações escritas no CLAUDE.md sejam lidas, o "peso do contexto"—como discussões sobre um bug de três dias atrás ou a lógica por trás de uma política de design decidida na semana passada—desaparece completamente.

Um desenvolvedor escreveu:

apenas 30 dias do histórico da sua sessão do Claude Code são salvos no seu computador por padrão, você precisa configurar um período maior se quiser ter memória de todas elas.

O período de retenção padrão para o histórico de sessões é de 30 dias. Além disso, o que é salvo é apenas um "registro como uma string", não um mecanismo que pode ser invocado como contexto.

É basicamente a mesma coisa no lado do Codex. O contexto do GPT-5.5 é de 1M de tokens via API e 400K no Codex CLI. O tamanho físico parece suficiente, mas, na prática, a precisão começa a cair por volta de 200K tokens.

Foi quando o Agentmemory, que ganhou destaque após ultrapassar 4.000 Stars, chegou. Estou usando-o intensamente há uma semana. Aqui está minha conclusão:

A expressão "adicionar memória infinita" ao Codex/Claude Code é metade hipérbole e metade verdade.

Neste artigo, explicarei como maximizar a parte da "verdade" e como evitar a parte da "hipérbole" quando você se deparar com ela.

1. Por que o Codex/Claude Code Sofrem de "Amnésia"?

Antes de discutir o Agentmemory, deixe-me esclarecer por que as ferramentas existentes não são suficientes. Se pularmos isso, tudo acaba em "adicionei uma ferramenta de memória conveniente" e perdemos a essência.

Mesmo que a janela de contexto seja grande, ela não pode ser totalmente utilizada na prática.

Em maio de 2026, as janelas de contexto dos principais modelos são as seguintes:

● Claude Opus 4.7: 1M de tokens (expandido de 200K)

● GPT-5.5: 1M de tokens (API) / limite de 400K no Codex CLI

● Gemini 3.1 Pro: 1M de tokens

Em termos de caracteres, isso é cerca de 1,41 milhão de caracteres. É capacidade suficiente para caber não apenas um livro, mas uma série inteira. Olhando os números, parece que "tudo cabe".

No entanto, a própria Anthropic escreveu em seu blog oficial de engenharia:

À medida que o número de tokens na janela de contexto aumenta, a capacidade do modelo de recuperar informações com precisão desse contexto diminui.

Capacidade física não é igual à capacidade de manter a precisão. A experiência mostra que, por volta de 200K a 400K tokens, o Claude começa a "esquecer o que acabou de dizer". Isso é comumente conhecido como context rot.

"Colapso do Pensamento" que ocorreu até mesmo no Claude Code oficial

Deixe-me dar um exemplo real. Em 23 de abril de 2026, a Anthropic divulgou oficialmente uma análise post-mortem.

Um bug lançado em 26 de março fez com que o "recurso de limpar pensamentos antigos após 1 hora de inatividade" fosse acionado a cada turno, mesmo após retomar uma sessão.

Como resultado, o comprimento médio do pensamento visível mudou da seguinte forma:

● Janeiro: 2.200 caracteres

● Março: 600 caracteres

Um colapso de 73%. Por cerca de um mês, o Claude Code oficial estava cortando arbitrariamente seu próprio contexto.

Isso é importante porque mostra que o apodrecimento do contexto não é apenas um "erro do usuário", mas também pode acontecer devido a circunstâncias do lado do serviço. Não importa o quão claramente você escreva o CLAUDE.md, um único ajuste de configuração no lado da ferramenta pode transformar o "contexto da semana passada" em papel rasgado.

Limites das soluções existentes (CLAUDE.md / auto-memory)

A Anthropic está tomando medidas. O recurso auto-memory do Claude Code é um mecanismo que lembra o que foi aprendido entre as sessões e o recupera ao reiniciar. A equipe do Claude Code anunciou isso em maio.

No entanto, isso é estruturado para funcionar em conjunto com a compactação. Ele realiza um fluxo interno de "comprimir contexto → mover informações importantes para a memória", e a IA decide "o que manter" durante cada compactação. Os usuários não podem tocar nessa lógica de decisão.

Além disso, o auto-memory é exclusivo do Claude Code. Não há API para lê-lo de outros agentes como Codex, Cursor, Cline ou Hermes. Para aqueles que usam vários agentes, a situação de ter que "explicar a mesma premissa três vezes" se torna normalizada.

2. Como o Agentmemory é Diferente

Agora, o tópico principal. O Agentmemory (repositório oficial: rohitg00/agentmemory) é um mecanismo de memória de código aberto que alcançou 8,8k Stars em 15 de maio de 2026. Mais que dobrou desde o relatório inicial de "4.000+ Stars". É licenciado sob Apache 2.0, baseado em TypeScript, e a versão mais recente é a v0.9.12 (13 de maio). É completamente auto-hospedado, com zero dados enviados para SaaS externos.

Filosofia do Desenvolvedor

O desenvolvedor principal, Rohit Ghumare (@ghumare64), resumiu a essência do Agentmemory em uma frase:

Construí isso há 6 meses com agentmemory: memória persistente para agentes de codificação de IA. Mesma ideia central: pare de re-derivar, comece a compilar.

"Pare de re-derivar, comece a compilar." Esta é a diferença filosófica das ferramentas existentes.

O CLAUDE.md era uma "entrada para re-derivar toda vez". Estrutura do projeto, convenções, decisões passadas. A IA releria, reinterpretaria e depois esqueceria tudo a cada sessão. O Agentmemory muda isso substituindo o "loop de re-derivação" por uma "camada de memória compilada".

Arquitetura de 3 Camadas (Resumo do README)

De acordo com o README oficial, a estrutura interna é dividida em três estágios:

Primeiro está o Capture. Ele usa 12 hooks do ciclo de vida do Claude Code para capturar dados automaticamente, eliminando a necessidade de executar memory_save manualmente.

Segundo está o Pipeline. Ele organiza as observações através de um fluxo de desduplicação → filtro de privacidade (remoção automática de chaves de API/PII) → compressão baseada em IA.

Terceiro está o Retrieval. Ele funde três tipos de pesquisa híbrida (BM25 / vetorial / grafo) usando RRF k=60. O BM25 lida com stemming de palavras-chave e expansão de sinônimos, o vetorial lida com similaridade de cosseno de embeddings densos, e o grafo lida com travessia de grafo de conhecimento. Ao fundi-los com o Reciprocal Rank Fusion, se um método falhar, o outro compensa. Os resultados são retornados com dispersão de sessão (máx. 3 por sessão), resolvendo o problema de obter resultados apenas da mesma sessão.

Memória de 4 níveis (Inspirada em Ebbinghaus)

Outro aspecto interessante é o design que divide a memória em quatro níveis que "crescem" ao longo do tempo.

O nível inferior é Working, que é a memória de curto prazo, como observações brutas de execução de ferramentas, logs de erro e histórico de comandos. Subindo para Episodic, tornam-se resumos de sessão do "que aconteceu". No nível Semantic, transforma-se em "o que eu sei", conhecimento extraído e padrões. O nível superior é Procedural, que consiste em fluxos de trabalho e procedimentos sobre "como proceder".

Memórias acessadas com frequência são fortalecidas, enquanto memórias não referenciadas decaem de acordo com a curva de esquecimento de Ebbinghaus. É um mecanismo modelado a partir da estrutura da memória humana. Esta é a verdadeira natureza de "parar de re-derivar e começar a compilar".

Posicionamento em Relação aos Concorrentes

Para ser honesto, olhando apenas para as Stars do GitHub, o Agentmemory é ainda pequeno em comparação com os concorrentes.

● Mem0: 55,7k Stars, camada de memória de uso geral, API/Cloud first

● Letta (antigo MemGPT): 22,7k Stars, sistema operacional de agente, gerenciamento de contexto virtual

● Agentmemory: 8,8k Stars, especializado em agentes de codificação, SQLite local

Ele perde no jogo dos números. No entanto, onde o Agentmemory se destaca é em sua especialização para agentes de codificação e design desacoplado. O próprio Rohit escreveu:

Se você quer uma arquitetura de memória estendida real, entre agentes, portátil, não vinculada a um agente específico, dê uma olhada no agentmemory. Ele é projetado como uma camada de memória desacoplada que funciona em vários harnesses.

Você pode conectar ao Cursor, Cline, Claude Code, Codex e Hermes usando a mesma memória. Esta é a diferenciação do Mem0 e Letta. O Mem0 é muito geral e tem captura automática fraca para contextos de codificação, enquanto o Letta é um sistema operacional de agente, dificultando a extração apenas da camada de memória.

O Agentmemory acerta em cheio o nicho de "desenvolvedores que usam múltiplos agentes de codificação simultaneamente."

3. Começando em 3 Minutos — Instalação e Configuração Inicial

Vamos colocar a mão na massa. O fluxo básico é o mesmo para Mac, Linux e Windows, desde que você tenha um ambiente Node.js.

Passo 1: Inicie o Servidor de Memória

Basta abrir um terminal e executar isto:

Inicie o servidor de memória (mantenha-o em execução)

npx @agentmemory/agentmemory

A primeira vez leva de 1 a 2 minutos para baixar as dependências. Uma vez bem-sucedido, uma API REST será iniciada em http://localhost:3111. Você pode verificar a saúde com:

curl http://localhost:3111/agentmemory/health

→ {"status":"ok","version":"0.9.12"}

Um visualizador também é iniciado, para que você possa visualizar o conteúdo da memória abrindo http://localhost:3113 em seu navegador.

Passo 2: Insira Dados de Demonstração

É difícil visualizar com conteúdo vazio, então vamos adicionar dados de exemplo.

Execute em um terminal separado

npx @agentmemory/agentmemory demo

Isso escreve um histórico de sessão fictício no SQLite, tornando-o observável no visualizador.

Passo 3: Integre ao Claude Code

A maneira mais rápida pelo lado do Claude Code é através do marketplace de plugins.

Execute dentro do Claude Code

/plugin marketplace add rohitg00/agentmemory

/plugin install agentmemory

Isso registra automaticamente o seguinte:

● 12 hooks (todos os ciclos de vida, incluindo SessionStart / PostToolUse / Stop)

● 4 skills (recall / consolidate / export / governance)

● 51 ferramentas MCP (AGENTMEMORY_TOOLS=all para todas, o padrão são 15 ferramentas principais)

Passo 4: Integre ao Codex CLI

O Codex segue um estilo semelhante.

codex plugin marketplace add rohitg00/agentmemory

codex plugin install agentmemory

Para o Codex, AGENTMEMORY_URL=http://localhost:3111 é automaticamente definido como uma variável de ambiente. Observe que o Codex é mais rigoroso quanto à sincronicidade do MCP do que o Claude Code, então ele gerará erro imediatamente se o servidor estiver inativo. Não se esqueça de mantê-lo em execução.

Passo 5: Conecte ao Cursor / Cline, etc.

Para usar via Cursor, adicione-o ao ~/.cursor/mcp.json:

{

"mcpServers": {

"agentmemory": {

"command": "npx",

"args": ["-y", "@agentmemory/mcp"],

"env": { "AGENTMEMORY_URL": "http://localhost:3111" }

}

}

}

Cline, Hermes e outros editores compatíveis com MCP se conectam no mesmo padrão. Há uma armadilha em que as configurações MCP do Cursor não são refletidas apenas fechando e reabrindo; detalharei isso na seção "5 Armadilhas".

Passo 6: Ritual de Verificação de Saúde

Após a configuração, aqui está a lista de verificação obrigatória:

1. Conectividade do servidor de memória

curl http://localhost:3111/agentmemory/health

2. Verifique a versão do iii-engine (v0.11.2 necessária)

iii --version

3. Verifique a memória no visualizador

open http://localhost:3113

Se você vir observações registradas no visualizador, a configuração foi bem-sucedida. Se o Node.js já estiver instalado, leva menos de 3 minutos.

4. As 3 Ações Básicas — Salvar, Pesquisar, Auto-Comprimir

O uso do Agentmemory pode ser organizado em três ações principais.

Ação 1: Salvar (Captura Automática é o Padrão)

No Mem0 ou Letta, é normal salvar usando comandos manuais como memory_add(...). O Agentmemory tem uma filosofia diferente: ele captura tudo automaticamente usando 12 hooks.

Por exemplo, as seguintes observações são registradas sem que você faça nada:

● Comandos e saída durante a execução da ferramenta Bash (hook PostToolUse)

● Diffs antes e depois da edição de arquivos (hook PreToolUse / PostToolUse)

● Injeção automática de memória relacionada no início da sessão (hook SessionStart)

● Compressão de resumo no final da sessão (hook Stop)

O maior valor é que o "fardo de o usuário decidir o que salvar" se torna zero. Enquanto antes pensávamos "isso é importante, vamos anotar" ou "vamos deletar isso" no CLAUDE.md, a ideia aqui é deixar essa lógica de decisão para a IA.

Você também pode salvar manualmente. Chamando memory_save através de uma ferramenta MCP, você pode marcar explicitamente "isso é importante". É mais seguro salvar manualmente decisões críticas de design do que confiar apenas na captura automática.

Ação 2: Pesquisar (Híbrido de 3 Sistemas + RRF)

A pesquisa é feita através de ferramentas MCP ou acessando a API REST diretamente. Aqui estão as ferramentas MCP representativas:

● memory_recall — Recupera memória relacionada usando linguagem natural

● memory_smart_search — Versão completa da pesquisa híbrida

● memory_sessions — Lista por sessão

● memory_timeline — Ordena por tempo

● memory_relations — Travessia de grafo de entidades relacionadas

Se for acessar a API REST diretamente:

Pesquise por "correção anterior sobre autenticação Supabase"

curl -X POST http://localhost:3111/agentmemory/search \

-H "Content-Type: application/json" \

-d '{"query": "correção auth supabase", "limit": 5}'

Os resultados retornados são uma fusão de BM25 / vetorial / grafo usando RRF k=60. A latência é inferior a 20ms no P50 (rápido porque é SQLite local).

A precisão em benchmarks oficiais (LongMemEval-S, 500 perguntas, ICLR 2025) é a seguinte:

● R@5: 95.2% (Probabilidade de que a resposta correta esteja entre os 5 principais candidatos)

● R@10: 98.6%

● MRR: 88.2%

Observe que isso é "precisão de pesquisa", não "precisão de QA ponta a ponta". É a probabilidade de que a resposta correta esteja em algum lugar entre os candidatos; se o Claude a usará para responder corretamente é uma questão separada. Não confie excessivamente nisso confundindo os dois conceitos.

Ação 3: Auto-Compressão (Crescendo em 4 Níveis ao Longo do Tempo)

Toda vez que o hook Stop é executado, três estágios de compressão ocorrem em ordem:

Primeiro, Working → Episodic colapsa logs brutos de ferramentas em resumos de sessão. Em seguida, Episodic → Semantic extrai "padrões" e "conhecimento" de múltiplos eventos de sessão. Finalmente, Semantic → Procedural solidifica etapas frequentemente repetidas em "fluxos de trabalho".

Isso resolve automaticamente o problema de "salvar tudo e criar ruído na pesquisa". O orçamento de tokens injetado no início da sessão é de 2.000 tokens por padrão. Isso é projetado para restaurar o "contexto anterior" de forma necessária e suficiente.

5. Fluxo de Trabalho para Usar Codex / Claude Code em Conjunto

Agora, para a aplicação prática. Para aqueles que usam seriamente tanto o Codex quanto o Claude Code, aqui estão três padrões de fluxo de trabalho.

Padrão 1: Fluxo Diário para Desenvolvimento Solo

Mantendo o servidor agentmemory em execução, o hook SessionStart é acionado quando o Claude Code é iniciado, injetando automaticamente a memória Episodic do dia anterior. Mesmo sem dizer "Continuar de ontem", a conversa começa com o Claude já entendendo "Vamos continuar a discussão sobre o problema com o RLS do Supabase."

Durante a codificação, o hook PostToolUse continua escrevendo comandos, saídas e diffs no SQLite. Quando a sessão é encerrada, o hook Stop comprime Working em Episodic. Na manhã seguinte, isso é lido automaticamente, completando o ciclo.

Padrão 2: Gerenciando Múltiplos Projetos

O Agentmemory pode dividir a memória em três escopos. O escopo user está vinculado ao indivíduo, contendo "hábitos pessoais" como preferências de convenção de codificação. O escopo project é gerenciado separadamente para cada projeto, com arquivos SQLite separados. O escopo local permanece apenas naquela máquina e não é compartilhado mesmo no modo de compartilhamento em equipe.

Ao alterar a variável de ambiente para AGENTMEMORY_PROJECT=foo-app ao mudar de projetos, um arquivo SQLite diferente é referenciado. Isso é incrivelmente eficaz para pessoas que executam vários projetos em paralelo. O fenômeno em que decisões de design do Projeto A se infiltram nas discussões do Projeto B acontecia frequentemente com o CLAUDE.md. Com o Agentmemory, eles estão fisicamente separados, portanto não há interferência.

Padrão 3: Compartilhamento em Equipe e Desenvolvimento Conjunto com Empresas Listadas

Atualmente, estamos co-desenvolvendo agentes de IA com empresas listadas, e o modo de compartilhamento do servidor MCP é sutilmente eficaz aqui. Ao definir o sinalizador collab=true, várias instâncias do Codex / Claude Code podem referenciar o mesmo servidor de memória.

Lado do servidor

AGENTMEMORY_COLLAB=true npx @agentmemory/agentmemory --bind 0.0.0.0

Ao referenciá-lo através de uma VPN da equipe, várias pessoas podem trabalhar enquanto compartilham a "memória do mesmo projeto". No entanto, o filtro de privacidade deve ser configurado com rigor. Se chaves de API ou informações pessoais forem misturadas, elas serão compartilhadas com toda a equipe, portanto, configurações de exclusão em .agentmemoryignore são obrigatórias. Tocarei nisso na seção "Armadilhas".

Armadilhas Exclusivas do Uso Conjunto

Ao alternar entre Codex e Claude Code no mesmo projeto, a memória é compartilhada, mas a sintaxe do prompt é diferente. O comando /plugin do Claude Code não funciona no Codex, e o comando codex plugin install do Codex não funciona no Claude Code. Mesmo sendo uma "ferramenta que funciona para ambos", as configurações são necessárias individualmente. Muitas pessoas ficam presas aqui na primeira semana.

6. Como Ler os Benchmarks — Traduzindo Números para "Experiência"

Vou traduzir os números oficiais para sensações práticas.

A Verdade Por Trás da "Redução de 92% de Tokens"

A "redução de 92%" divulgada em flashes de notícias e artigos do Medium é por sessão.

● Operação manual convencional com CLAUDE.md: aproximadamente 22.000 tokens por sessão

● Via Agentmemory: aproximadamente 1.900 tokens por sessão

● Taxa de redução: aproximadamente 91-92%

Os tokens de injeção de contexto no início de uma sessão são drasticamente reduzidos. Anualmente, os números mudam, e a tabela de Economia de Tokens no README diz:

● Operação resumida por LLM: aproximadamente 650K tokens / ano (aproximadamente $500 / ano)

● Agentmemory: aproximadamente 170K tokens / ano (aproximadamente $10 / ano)

Em termos de tokens, é cerca de 74% de redução, mas em termos de custo, é uma redução de 98%. $500 se tornam $10. A razão para a diferença é que o Agentmemory é executado em SQLite local + embeddings locais. Ao contrário do Mem0 ou Letta, que executam compressão baseada em LLM toda vez, o custo operacional é mínimo.

O Que "LongMemEval-S R@5 95.2%" Significa

LongMemEval-S é um benchmark de memória de longo prazo lançado no ICLR 2025 (500 perguntas, aproximadamente 48 sessões por pergunta, aproximadamente 115K tokens de contexto). Comparando as principais ferramentas:

O Mem0 está se aproximando com seu novo algoritmo, então não é justo chamar isso de "vitória esmagadora" com base apenas nos números. No entanto, como o Agentmemory atinge 95,2% em combinação com um mecanismo de captura automática especializado para agentes de codificação, a avaliação atual é que ele está em uma posição excelente para o trade-off "precisão vs. carga operacional".

Para reiterar, R@5 é precisão de pesquisa, não a probabilidade de que Claude ou Codex darão a resposta correta no final. Confundir esses conceitos leva à supervalorização.

Codex 400K vs Opus 4.7 1M: "Físico vs. Prático"

Olhando para os números dos benchmarks, notei outro ponto importante.

O Claude Opus 4.7 expandiu seu contexto para 1M de tokens. O GPT-5.5 também tem 1M de tokens via API. Olhando apenas para isso, parece que "não precisamos mais de ferramentas de memória."

No entanto, o Codex CLI está, na verdade, limitado a 400K. O limite físico e o limite prático estão desalinhados. Além disso, como a própria Anthropic escreveu, o apodrecimento do contexto começa em 200K-400K tokens à medida que o contexto aumenta.

Em outras palavras, mesmo que o tamanho físico aumente, a necessidade de um mecanismo de memória não diminui. Pelo contrário, "como usar eficientemente uma janela de contexto ampla" tornou-se um novo desafio técnico.

7. 5 Armadilhas — Minas Terrestres que Eu Mesmo Pisei

Serei honesto aqui. Aqui estão 5 minas terrestres em que pisei enquanto executava o sistema, que não aparecem no README oficial ou nos tweets de influenciadores. Selecionei apenas aquelas reproduzíveis a partir das Issues do GitHub.

Armadilha 1: Incompatibilidade de Versão do iii-engine v0.11.2

Imediatamente após a configuração, algumas pessoas recebem este erro:

iii: command not found

Ou

Version mismatch: expected v0.11.2, got v0.11.0

O Agentmemory depende internamente de um binário chamado iii-engine, e a versão está fixada na v0.11.2. Se outra versão já estiver instalada, ele falha no estágio de inicialização. A solução alternativa é buscar a versão fixa nos releases para cada sistema operacional.

macOS arm64

curl -fsSL https://github.com/iii-hq/iii/releases/download/iii/v0.11.2/iii-aarch64-apple-darwin.tar.gz \

chmod +x ~/.local/bin/iii

Linux x64

curl -fsSL https://github.com/iii-hq/iii/releases/download/iii/v0.11.2/iii-x86_64-unknown-linux-gnu.tar.gz \

Verificação

iii --version # Deve mostrar v0.11.2

Se você pular isso, todo o resto falhará mais tarde, então resolva isso primeiro.

Armadilha 2: Issue #181 — Produção em Massa de Sessões Fantasmas via Loop Infinito

Esta é seriamente perigosa. Um bug fatal reportado na v0.9.1 onde chamar /summarize do hook Stop sem uma chave de API configurada causa geração infinita de sessões filhas.

Stop hook → /summarize → Sessão filha gerada

↓

O hook Stop da sessão filha também é acionado → /summarize → Mais sessões filhas

↓

(Loop infinito)

Há um relato na Issue #181 do GitHub de que cerca de 579 sessões fantasmas foram geradas em poucos minutos. Existem três soluções alternativas:

Opção 1: Desabilitar o modo agent-sdk (Recomendado)

export AGENTMEMORY_ALLOW_AGENT_SDK=false

Opção 2: Forçar erro com uma chave de API falsa

export AGENTMEMORY_ANTHROPIC_API_KEY="fake-key"

Opção 3: Definir uma chave de API real

export AGENTMEMORY_ANTHROPIC_API_KEY="sk-ant-..."

Para uso em produção, a Opção 1 ou 3 é segura. A Opção 2 é apenas para o primeiro dia em que você "só quer fazer funcionar".

Armadilha 3: Issue #159 — MCP e API REST Rodando em KVs Separados

Este é outro fenômeno que faz você coçar a cabeça se não souber. Chamar uma ferramenta MCP (como memory_search) retorna resultados vazios toda vez, mas a API REST (POST /agentmemory/search) encontra resultados com os mesmos dados.

API REST: GET /agentmemory/sessions → 69 observações

Ferramenta MCP: memory_sessions → [] (vazio)

A causa é que o pacote @agentmemory/mcp e o servidor Agentmemory são projetados para ter armazenamentos KV completamente separados (Issue #159). O MCP é "KV local" e o servidor é "outro KV", sem caminho de comunicação entre eles. Em maio de 2026, a issue permanece em aberto. As soluções alternativas são:

● Opção 1: Use a API REST diretamente (via curl ou fetch em vez de ferramentas MCP)

● Opção 2: Desabilite temporariamente o hook /mcp e execute apenas o servidor

Há planos para corrigir isso no futuro, mas, por enquanto, você precisa contornar essa especificação.

Armadilha 4: MCP Não Refletido no Cursor / VSCode

Você editou ~/.cursor/mcp.json e reiniciou o Cursor, mas o Agentmemory não aparece em /mcp list. Isso acontece não apenas com o Cursor, mas com aplicativos da Windows Store em geral.

Fechar com o botão "X" da GUI deixa o processo em segundo plano do WindowsApps em execução por padrão. O processo antigo continua rodando com as configurações antigas na memória. Um ritual de encerramento completo é necessário.

macOS

pkill -9 Cursor

Armadilha 5: Vazamento de Configuração ao Compartilhar Chaves de API no Modo Colaborativo

Conforme mencionado no Padrão 3, ao usar AGENTMEMORY_COLLAB=true em equipe, filtros de privacidade insuficientes podem expor chaves de API de membros da equipe. Por padrão, o Agentmemory usa regex para remover strings que correspondem a padrões como sk-ant-... e AKIA..., mas não é 100% infalível. O curl executado em uma sessão anônima pode conter chaves de API em cabeçalhos ou parâmetros de URL que o regex não cobre.

A medida preventiva é:

echo "*.env" >> .agentmemoryignore

echo "secret" >> .agentmemoryignore

echo "credential" >> .agentmemoryignore

Sem isso, há o risco de alguém sem querer enviar uma chave de API da produção para o servidor de memória compartilhado, e todos os membros da equipe poderem vê-la. Não se esqueça.

Resumo: O Que Você Pode e Não Pode Fazer com o Agentmemory

Para terminar, resumirei o que foi discutido.

O que o Agentmemory pode fazer:

● Manter o contexto entre sessões do Claude Code de forma independente da compactação oficial

● Compartilhar memória entre Codex / Claude Code / Cursor / Cline

● Reduzir custos de tokens em direção a cerca de 10 dólares por ano

● Tornar observações pesquisáveis com 95% de precisão de recall

O que o Agentmemory não pode fazer:

● Evitar completamente o apodrecimento do contexto (não importa quanta memória você adicione, a IA eventualmente se perderá)

● Garantir precisão de QA ponta a ponta de 95% (pesquisa e resposta correta são coisas diferentes)

● Transferir magicamente o contexto de design de uma empresa listada para suas operações (a capacidade de julgamento humano ainda é necessária)

3 Pontos-Chave da Jornada de uma Semana de Uso Intensivo

1. O primeiro dia é uma batalha de configuração: incompatibilidade de versão do iii-engine, erros de plugin do Codex, e o Cursor não reflete o MCP. Se você sobreviver a isso, as coisas ficarão mais fáceis do segundo dia em diante.

1. Há uma lacuna entre a teoria do benchmark e a prática: o R@5 de 95% é a taxa de inclusão em candidatos de pesquisa, não a taxa na qual a IA realmente a utiliza para respostas corretas. A taxa de precisão de uso final depende também do modelo e da engenharia de prompt, que atualmente é de cerca de 70-80%.

1. O maior valor está na inferência de contexto zero para sessões: leva apenas 3 segundos para iniciar uma nova sessão. Sem a tarefa de explicar o projeto toda vez. Isso representa uma enorme diferença anual na qualidade do fluxo de trabalho.

Por último, uma coisa importante.

Independentemente da ferramenta, ela não será útil a menos que você mesmo a experimente. É a mesma sensação que você tem quando diz "vou tentar usá-la por uma semana". É uma ferramenta que mostra seu valor depois que você a experimenta na prática.

open /Applications/Cursor.app

Windows (PowerShell)

→ Reiniciar

Se você fizer da "verificação de processos residuais" seu padrão antes de duvidar do arquivo de configuração, vai economizar tempo aqui.

Armadilha 5: Observações Silenciosamente Descartadas pelo Filtro de Privacidade

O fenômeno em que "o servidor está rodando, mas as observações não aparecem no visualizador" também acontece com frequência na primeira semana. Olhando os logs, você verá avisos como este:

[warn] observation dropped: private_tag detected

[warn] observation dropped: private_email detected

Isso é por design, não um bug. O filtro de privacidade do Agentmemory detecta automaticamente chaves de API, senhas, endereços de e-mail e PII, e descarta essas observações sem registrá-las. É um ótimo recurso para segurança, mas se você não souber disso, vai pensar que "não está funcionando". A estratégia de coexistência é:

Excluir por arquivo usando .agentmemoryignore

echo ".env" >> .agentmemoryignore

echo ".env.local" >> .agentmemoryignore

echo "*/.key" >> .agentmemoryignore

echo "*/password*" >> .agentmemoryignore

Especialmente ao executar código experimental que inclui chaves de API nas observações, é seguro colocar este arquivo antecipadamente.

8. Resumo — "Memória Infinita" Não É Apenas Expansão da Janela de Contexto

Depois de usar o Agentmemory intensamente por uma semana, esta é a sensação que mais fez sentido: A expressão "memória infinita" não se refere à expansão física da janela de contexto.

Mesmo que aumente para 1 milhão de tokens, se a precisão cair em 200 mil, no final das contas é inútil. Sinto que a corrida pelo tamanho físico já acabou. Em vez disso, o que o Agentmemory permite que você obtenha é um cérebro externo semântico.

Mantenha a memória estruturada fora da sessão, não dentro. Chame apenas o que você precisa quando precisar e feche quando terminar. Coisas que valem a pena lembrar crescem com o tempo, enquanto coisas que podem ser esquecidas se deterioram silenciosamente. É a mesma estrutura de como os humanos usam a memória.

A mudança que ocorre na mente de um desenvolvedor pode ser descrita em uma frase: uma transição de "acaba quando a sessão é encerrada" para "a memória cresce entre as sessões".

Toda a indústria está se movendo nessa direção. O curso de memória de agentes da DeepLearning.AI, a mensagem da Mem0 sobre "tornar agentes sem estado em agentes com estado", o artigo MemGPT "LLMs como Sistemas Operacionais" — no final, tudo isso se resume a memória externa, e o Agentmemory é uma solução no contexto do agente de codificação.

Seja Mem0, Letta ou sua própria implementação, para aqueles que usam seriamente Codex / Claude Code, é atualmente a ferramenta mais rápida para experimentar a "sensação de memória infinita". Sinceramente, vale a pena instalar.

9. Sobre Esta Conta

Para aqueles que leram até aqui: esta conta @Codestudiopjbk é gerida por três usuários hardcore do Codex.

● Participação em programas de desenvolvimento para alunos de pós-graduação e pós-doutorado

● Ganhou 300.000 ienes em prêmios

● Atualmente codesenvolvendo agentes de IA com empresas de capital aberto

Nosso conteúdo habitual inclui:

● Exemplos de implementação usando GPT-5.5 / OpenAI Codex

● Utilização do Codex, automação de CLI e tendências de desenvolvimento

● Tradução e verificação das informações mais recentes do exterior sobre GPT-5.5 / Codex

● Comparações práticas com Claude Code (baseadas em centenas de horas de uso)

● Aprendizados de codesenvolvimento com empresas de capital aberto

Publicamos diariamente sobre todo o processo de levar um produto funcional ao mundo, desde a filosofia de desenvolvimento até design, implementação e melhoria. Se tiver interesse, por favor, siga e confira. Valerá a pena.

Para consultorias relacionadas a desenvolvimento, envie-nos uma DM. Sinta-se à vontade para entrar em contato para introdução ao Codex, design de automação ou implementação de agentes de IA.

Referências e Citações

● [Rohit Ghumare (rohitg00/agentmemory)] (2026-05-13) Agentmemory v0.9.12 — Mecanismo de Memória para Agentes de Codificação — Repositório oficial, Apache-2.0, 8,8 mil estrelas, TypeScript

● [Rohit Ghumare] (2026-04) "Construí isso há 6 meses com agentmemory: memória persistente para agentes de codificação de IA" — Filosofia do desenvolvedor

● [GitHub Issue #181] Stop-hook → /summarize → recursão infinita do agent-sdk — Fonte principal para a Armadilha 2

● [GitHub Issue #159] Ferramentas MCP independentes não fazem proxy para o servidor agentmemory em execução — Fonte principal para a Armadilha 3

● [Anthropic Engineering] Engenharia de Contexto Eficaz para Agentes de IA — Orientação oficial sobre engenharia de contexto

● [Anthropic] (2026-04-23) Postmortem de 23 de abril — Prova social do incidente de colapso no comprimento do pensamento do Claude Code

● [Mem0] Apresentando a Mem0 — Filosofia da Mem0 e citação de Taranjeet Singh

● [Letta] Benchmarking de Memória de Agentes de IA — Fonte para os números de benchmark da Letta

● [Charles Packer et al.] (2023-10) MemGPT: Rumo a LLMs como Sistemas Operacionais — Artigo sobre gerenciamento de contexto virtual, predecessor teórico do Agentmemory

● [DeepLearning.AI] Memória de Agente: Construindo Agentes Conscientes de Memória — Curso de Andrew Ng / Oracle