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 que a conversa seja interrompida? O nome dele é Agentmemory. Resumi tudo, desde o procedimento de instalação e configuração até as armadilhas comuns. É uma 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 a resposta "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 coisas 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 é salvo no seu computador por padrão, você precisa definir um período maior se quiser ter memória de todas elas.

O período de retenção padrão para o histórico da sessão é de 30 dias. Além disso, o que é salvo é apenas um "registro como uma string", não um mecanismo que pode ser evocado 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 então que o Agentmemory, que virou notícia após ultrapassar 4.000 Stars, chegou. Eu o tenho usado intensamente por uma semana. Aqui está minha conclusão:

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

Neste artigo, vou explicar como maximizar a parte da "verdade" e como evitar a parte do "exagero" 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 japoneses, 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.

A 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 degradação de contexto (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 publicou 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" disparasse a cada turno mesmo após retomar uma sessão.

Como resultado, o comprimento mediano 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 a degradação de 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 executa um fluxo interno de "compactar 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 normal.

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 atingiu 8,8k Stars em 15 de maio de 2026. Mais que dobrou desde o relatório inicial de "mais 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 externo.

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 rederivar, comece a compilar.

"Pare de rederivar, comece a compilar." Essa é a diferença filosófica das ferramentas existentes.

O CLAUDE.md era um "input para rederivar toda vez". Estrutura do projeto, convenções, decisões passadas. A IA os lia, reinterpretava e depois os esquecia a cada sessão. O Agentmemory muda isso substituindo o "loop de rederivaçã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á a Captura (Capture) . Ela usa 12 hooks do ciclo de vida do Claude Code para capturar dados automaticamente, então não há 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á a Recuperação (Retrieval) . Ela funde três tipos de busca híbrida (BM25 / vetorial / grafo) usando RRF k=60. BM25 lida com palavras-chave de stemming e expansão de sinônimos, vetorial lida com similaridade de cosseno de embeddings densos, e grafo lida com travessia de grafo de conhecimento. Ao fundi-los com o Rank Recíproco de Fusão (Reciprocal Rank Fusion), se um método falha, 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 é o Working (Operacional) , 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 (Episódica) , tornam-se resumos de sessão do "que aconteceu". No nível Semantic (Semântica) , transforma-se em "o que eu sei", conhecimento extraído e padrões. O nível superior é o Procedural (Procedimental) , que consiste em fluxos de trabalho e procedimentos sobre "como proceder".

Memórias frequentemente acessadas 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 rederivar e começar a compilar".

Posicionamento em Relação aos Concorrentes

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

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

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

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

Ele perde no jogo dos números. No entanto, onde o Agentmemory brilha é 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 presa a um agente específico, dê uma olhada no agentmemory. Ele é projetado como uma camada de memória desacoplada que funciona em várias estruturas.

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 SO de agente, dificultando extrair apenas a camada de memória.

O Agentmemory acerta em cheio no nicho de "desenvolvedores que usam vários 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 isso:

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. Assim que for bem-sucedido, uma API REST será iniciada em http://localhost:3111. Você pode verificar a integridade com:

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

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

Um visualizador também é iniciado, então você pode visualizar o conteúdo da memória abrindo http://localhost:3113 no seu navegador.

Passo 2: Insira Dados de Demonstração

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

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 do 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 Codex, AGENTMEMORY_URL=http://localhost:3111 é automaticamente definido como uma variável de ambiente. Observe que o Codex é mais rigoroso quanto à sincronicidade MCP do que o Claude Code, então ele emitirá um 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 conectam-se da mesma forma. Há uma armadilha onde 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 Integridade

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-Compressão

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 (hooks 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 do 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 em vez de 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 diretamente a API REST. 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 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": "supabase auth fix", "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 a resposta correta estar 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 a resposta correta estar 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 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 comprime 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 uma forma necessária e suficiente.

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

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 dispara 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 Supabase RLS."

Durante a codificação, o hook PostToolUse continua escrevendo comandos, saídas e diffs no SQLite. Quando a sessão é fechada, o hook Stop comprime Working em Episodic. Na manhã seguinte, isso é automaticamente lido, 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 sai, mesmo no modo de compartilhamento em equipe.

Ao alterar a variável de ambiente para AGENTMEMORY_PROJECT=foo-app ao trocar de projetos, um arquivo SQLite diferente é referenciado. Isso é incrivelmente eficaz para pessoas que executam vários projetos em paralelo. O fenômeno onde as decisões de design do Projeto A vazam para as discussões do Projeto B acontecia frequentemente com o CLAUDE.md. Com o Agentmemory, eles estão fisicamente separados, então 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, múltiplas 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 via uma VPN de equipe, várias pessoas podem trabalhar compartilhando 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, as configurações de exclusão em .agentmemoryignore são obrigatórias. Tocarei nisso na seção "Armadilhas".

Armadilhas Exclusivas do Uso em Dupla

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 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 nisso 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% nos Tokens"

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

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

● Via Agentmemory: aprox. 1.900 tokens por sessão

● Taxa de redução: aprox. 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: aprox. 650K tokens / ano (aprox. $500 / ano)

● Agentmemory: aprox. 170K tokens / ano (aprox. $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, aprox. 48 sessões por pergunta, aprox. 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" apenas com base 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 ótima posição no trade-off entre "precisão vs. carga operacional".

Para reiterar, R@5 é precisão de pesquisa, não a probabilidade de Claude ou Codex dar 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, a degradação de 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 Realmente 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 das GitHub Issues.

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 em v0.11.2. Se outra versão já estiver instalada, ele falha no estágio de inicialização. A solução é buscar a versão fixa nos releases para cada SO.

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 relatado na v0.9.1 onde chamar /summarize do hook Stop sem uma chave de API configurada causa a geração infinita de sessões filhas.

Stop hook → /summarize → Sessão filha gerada

↓

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

↓

(Loop infinito)

Há um relato na GitHub Issue #181 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 ver funcionando."

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

Este é outro fenômeno que te deixa coçando a cabeça se você 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.

REST API: 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). MCP é "KV local" e o servidor é "outro KV", sem caminho de comunicação de código entre eles. Em maio de 2026, a issue permanece aberta. 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: Desative 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 término completo é necessário.

macOS

pkill -9 Cursor

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, economizará tempo aqui.

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

O fenômeno em que "o servidor está em execução, mas as observações não aparecem no visualizador" também ocorre 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 de segurança, mas se você não souber disso, vai achar 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 com antecedência.

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

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

Mesmo que aumente para 1M de tokens, se a precisão cair em 200K, é inútil no final. Sinto que a corrida pelo tamanho físico já acabou. Em vez disso, o que o Agentmemory permite obter é 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 decaem 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 "termina quando a sessão é cortada" 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 do Mem0 sobre "tornar agentes stateless em stateful", o artigo do MemGPT "LLMs como Sistemas Operacionais"—no final, tudo isso é sobre memória externa, e o Agentmemory é uma solução no contexto de agentes de codificação.

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

9. Sobre Esta Conta

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

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

● Ganhou 300.000 ienes em prêmios

● Atualmente codesenvolvendo agentes de IA com empresas de capital aberto

Nosso conteúdo usual 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 sobre GPT-5.5 / Codex do exterior

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

● Aprendizados do desenvolvimento conjunto com empresas de capital aberto

Postamos diariamente sobre todo o processo de trazer um produto funcional ao mundo, desde a filosofia de desenvolvimento até design, implementação e melhoria. Se estiver interessado, por favor siga e dê uma olhada. Vale a pena.

Para consultas relacionadas a desenvolvimento, nos envie 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.8k 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 autônomas 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) April 23 Postmortem — Prova social do incidente de colapso do comprimento de pensamento do Claude Code

● [Mem0] Introducing Mem0 — Filosofia do Mem0 e citação de Taranjeet Singh

● [Letta] Benchmarking AI Agent Memory — Fonte para números de benchmark do Letta

● [Charles Packer et al.] (2023-10) MemGPT: Towards LLMs as Operating Systems — Artigo sobre gerenciamento de contexto virtual, predecessor teórico do Agentmemory

● [DeepLearning.AI] Agent Memory: Building Memory-Aware Agents — Curso de Andrew Ng / Oracle