Para memória de agente local e aberta, a recuperação é o padrão: pipelines RAG, pesquisa de agente, incorporação de armazenamentos e travessia de gráfico são o que a maioria dos construtores busca primeiro. Uma [pesquisa de 2026](https://arxiv.org/abs/2602.19320) conclui que o design da memória, e não a capacidade do modelo, é agora o fator limitante para agentes de longa vida.

A recuperação funciona bem para codificação e exploração, mas é interrompida quando os agentes lidam com o estado contínuo. Os principais projetos ([Zep](https://www.getzep.com/), [Mem0](https://mem0.ai/), [Letta](https://www.letta.com/), [LangMem](https://langchain-ai.github.io/langmem/)) estão adicionando resolução de entidade, persistência e estrutura gráfica, mas a convergência total para um design estruturado enfrenta barreiras que são difíceis de modernizar: consultas de primeiro esquema, identidade determinística, procedência somente anexada e controle local primeiro.

## Por que a recuperação domina

A recuperação se ajusta ao caso de uso que coloca os agentes no mapa: codificação. As bases de código são exploratórias, muitas vezes você não sabe onde as coisas estão e quer "onde lidamos com o X?" em vez de "listar todas as funções com proveniência". A pesquisa semântica e a travessia ad hoc são adequadas para isso.

A maioria das pessoas forma sua intuição sobre a memória do agente a partir da codificação, onde a recuperação é suficiente. O problema é generalizar a partir disso. Para estados operacionais como tarefas, contatos, transações e compromissos, você precisa da mesma resposta na próxima semana, conjuntos completos e trilhas de auditoria.

A recuperação também é barata para adicionar. Você pode incorporar seus documentos, conectar um armazenamento de vetores e ter memória de trabalho em uma tarde, sem design de esquema, sem resolução de entidade e sem rastreamento de procedência. Essa é uma vantagem real, não apenas inércia.

## Onde a recuperação é interrompida

As quebras aparecem quando você depende da memória do agente para obter a verdade.

**Respostas inconsistentes.** Perguntar "liste todas as tarefas do projeto X" retorna sete resultados em um dia e quatro no dia seguinte. A recuperação é reinferida a cada vez. [A pesquisa confirma](https://arxiv.org/abs/2512.12818) que os agentes combinam informações entre sessões e produzem respostas temporalmente inconsistentes à medida que a memória aumenta.

**Recordação incompleta.** Sistemas RAG com recuperação de recuperação abaixo de 80% mostram [taxas de alucinação de 34%, em comparação com 20% para sistemas acima de 90% de recuperação](https://www.ijmsrt.com/storages/download-paper/IJMSRT25SEP018). A recuperação baseada em incorporação descarta a estrutura temporal e relacional, e quanto mais entidades você tiver, pior será a recuperação.

**Sem procedência.** Quando você pergunta "de onde veio esse número?" a recuperação fornece uma resposta inferida de quaisquer pedaços que surgiram. Não há linhagem da resposta até os registros de origem.

**Gravações irrecuperáveis.** Quando um agente substitui um contato ou mescla tarefas, o estado anterior desaparece. Não há controle de versão nem reversão.

**Desvio entre ferramentas.** Uma tarefa criada no ChatGPT não pode ser consultada de forma confiável no Cursor. A memória do provedor é [imprevisivelmente inconsistente](https://www.datastudios.org/post/can-chatgpt-remember-previous-conversations-memory-behavior-session-limits-and-persistence), e as configurações de recuperação aberta também não são ferramentas cruzadas por padrão.

## O que o estado estruturado oferece

Estado estruturado significa um armazenamento com entidades digitadas, IDs estáveis, relacionamentos e cronogramas. A mesma consulta sempre retorna o mesmo resultado e você obtém origem e reversão.

| Necessidade | Loja estruturada | Recuperação |
|------|------------------|-----------|
| Conjunto completo ("todas as tarefas do projeto X") | Sim, por esquema e relacionamentos | Parcial ou inferido |
| Mesma resposta na próxima semana | Sim | Não |
| Rastrear até a origem | Sim, cadeia de proveniência | Não |
| Recuperar-se de gravação incorreta | Sim, se apenas anexar | Geralmente não |
| Consistência entre ferramentas | Sim, se for multiplataforma | Somente se todas as ferramentas compartilharem o mesmo backend |
| Explore o desconhecido | Possível, mas não a sua força | Sim, é aqui que a recuperação se destaca |
| Resumo único | Exagero | Sim |

Um armazenamento estruturado pode ter o formato de um gráfico, e o que estou construindo, [Neotoma](https://neotoma.io), é: uma camada de memória local compatível com MCP que fornece aos agentes uma única fonte de verdade para entidades, relacionamentos e linhagem. O que o separa das "configurações de gráfico" comuns na recuperação é a persistência, os IDs canônicos e a procedência. Escrevi mais sobre [por que a memória do agente precisa de uma camada de verdade](/posts/truth-layer-agent-memory) em outro lugar.

## Para onde o campo está se movendo

Os principais projetos estão convergindo para o estado estruturado do lado da recuperação.

**[Zep](https://www.getzep.com/)/[Graphiti](https://www.getzep.com/)** cria um [gráfico de conhecimento temporal](https://arxiv.org/abs/2501.13956) que atinge um ganho de precisão de 18,5% em relação ao MemGPT e uma redução de latência de 90%, e fornece um servidor MCP. É o estado mais próximo do estruturado no ecossistema atual.

**Mem0** usa um [pipeline de extração e consolidação de duas fases](https://mem0.ai/research) que relata uma precisão 26% maior do que a memória da OpenAI, com uma variante gráfica para relacionamentos de entidades. Ainda é principalmente a recuperação em primeiro lugar, e a camada estruturada é aditiva.

**[Letta](https://www.letta.com/)** (anteriormente [MemGPT](https://docs.letta.com/guides/legacy/memgpt-agents-legacy)) [persiste em todos os estados em um banco de dados](https://docs.letta.com/guides/agents/context-engineering) com blocos de memória editáveis. É o “estado estruturado” mais explicitamente dos projetos de origem de recuperação.

**[LangMem](https://langchain-ai.github.io/langmem/)/[LangGraph](https://langchain-ai.github.io/langgraph/)** oferece um [SDK de memória persistente](https://blog.langchain.com/langmem-sdk-launch/) com tipos semânticos, episódicos e procedimentais e consolidação de memória. A camada de persistência é real, mas o padrão de acesso primário ainda é a incorporação da pesquisa.

**[Hindsight](https://arxiv.org/abs/2512.12818)** ([pesquisa de 2025](https://arxiv.org/abs/2512.12818)) organiza a memória em quatro redes lógicas e atinge 83-91% de precisão em benchmarks de longo horizonte. Ele mostra a direção: a memória estruturada com redes de entidades explícitas supera a recuperação simples.

## Os sistemas de recuperação podem convergir totalmente?

Algumas coisas convergem naturalmente, mas outras são estruturalmente difíceis de modernizar.

**O que já está convergindo.** A extração de entidades e a estrutura do gráfico são reais em Zep e [Mem0g](https://mem0.ai/). A persistência do banco de dados é real no Letta e no LangGraph. O rastreamento temporal é real no Graphiti. Estes estão fechando a lacuna.

**Primeiro a similaridade versus primeiro o esquema.** O padrão de acesso padrão da recuperação é "encontrar coisas semelhantes". O padrão de uma loja estruturada é “consulta por tipo, ID, relacionamento ou horário”. Criar um esquema de sistema de recuperação primeiro significa alterar a superfície da API e as expectativas do usuário, não apenas adicionar um recurso.

**Identidade implícita versus explícita.** A recuperação trata dois pedaços como a mesma entidade se suas incorporações estiverem próximas. O estado estruturado trata dois registros como a mesma entidade se eles compartilharem um ID canônico. A modernização da identidade determinística significa alterar cada caminho de ingestão.

**Upsert versus somente acréscimo.** Os sistemas de recuperação geralmente sobrescrevem, enquanto o armazenamento somente de acréscimo preserva o histórico. Letta usa blocos de memória mutáveis ​​e Zep rastreia a evolução temporal, que está mais próxima. A maioria dos sistemas de recuperação não tem conceito de gravação de histórico.

**Procedência por meio de consolidação.** Quando Mem0 consolida fatos ou LangMem mescla memórias relacionadas, a procedência das fontes originais normalmente é perdida. A proveniência que sobrevive à fusão requer que o modelo de armazenamento a suporte desde o início.

**Determinismo.** A recuperação envolve classificação e os resultados variam de corrida para corrida. As consultas estruturadas são determinísticas: a mesma consulta retorna o mesmo resultado. A remoção da função de classificação prejudica o que torna a recuperação útil. Esses são contratos de consulta fundamentalmente diferentes.

**Controle local primeiro.** Tornar um sistema verdadeiramente local, sem dependência de nuvem e sem telemetria, entra em conflito com o modelo de negócios da maioria das empresas de memória. Esta não é uma barreira técnica; é um problema de incentivo estrutural.

Os sistemas de recuperação podem chegar parcialmente a um armazenamento estruturado, mas a última etapa requer consultas que priorizam o esquema, identidade determinística, proveniência somente de acréscimo, resultados determinísticos e padrões locais que priorizam. Essas escolhas vão contra a arquitetura da recuperação em primeiro lugar.

## O que a recuperação ainda faz melhor

**Exploração.** Quando você deseja encontrar algo em suas anotações sobre o apartamento em Barcelona, você não conhece o esquema ou o tipo de entidade. A recuperação revela bits relevantes sem modelagem inicial.

**Resumo.** Quando você pergunta ao contratante o que decidiu, a recuperação pode pesquisar, extrair e resumir em uma sessão. Você não precisa que essa resposta persista ou corresponda exatamente na próxima vez.

**Travessia ad hoc.** ​​Quando você pergunta onde os webhooks do Stripe são tratados, o layout varia entre bases de código e documentos. A recuperação se adapta sem um gráfico unificado.

**Baixo custo inicial.** Você pode ter memória de trabalho em uma tarde. Para qualquer coisa que não exija integridade, consistência ou procedência, a recuperação é suficiente e mais barata.

## Lacunas no estado estruturado e como Neotoma as aborda

**Sobrecarga de esquema.** Neotoma usa um registro de esquema em evolução onde a extração assistida por LLM propõe tipos e relacionamentos durante a ingestão. Isso reduz o custo inicial, mas não o elimina. Na prática, o agente revisa e corrige os resultados da extração ao longo do tempo à medida que encontra inconsistências.

**Complexidade de ingestão.** O Neotoma calcula IDs canônicos baseados em hash a partir da identificação de propriedades, para que a mesma entidade obtenha o mesmo ID, independentemente da origem. Isso é mais previsível do que a similaridade baseada em incorporação, mas depende da qualidade da extração: "Mark" e "Mark Hendrickson" fazem hash de maneira diferente até você mesclá-los.

**Início a frio.** O Neotoma oferece suporte à ingestão de caminho duplo: você pode fazer upload de arquivos para extração em lote ou acumular estado de forma incremental por meio de conversas com agentes. Isso não é instantâneo, mas é mais rápido do que esperar conversas suficientes para construir um gráfico útil.

**Custo apenas de acréscimo.** O armazenamento aumenta a cada correção, o que torna possível a reversão e a procedência. À escala pessoal e operacional isto é administrável, mas é uma verdadeira compensação: as consultas para resolver o estado atual são mais complexas.

**Não substitui a recuperação.** O Neotoma fornece recuperação estrutural por tipo, ID, relacionamento, intervalo de tempo e vizinhança gráfica, e espera ferramentas de recuperação como pesquisa de agente e pesquisa de incorporação para lidar com a exploração. É um complemento e não um substituto.

## Por que estou construindo o Neotoma

Atingi os limites de recuperação na prática. Tarefas, contatos e transações precisam de IDs canônicos, linhagem e acesso entre ferramentas. As escolhas de design respondem diretamente às barreiras de convergência descritas acima.

**Esquema primeiro.** As consultas são por tipo de entidade, ID, relacionamento ou intervalo de tempo. Não há semelhança de incorporação no caminho da consulta e os resultados são determinísticos.

**Identidade baseada em hash.** A mesma entidade obtém o mesmo ID, independentemente de qual fonte ou sessão o introduziu.

**Somente acréscimo.** Cada fato remonta à sua fonte. As correções criam novos registros e a reversão é possível.

**Ferramentas cruzadas via MCP.** Uma camada de memória é acessível a partir de qualquer cliente MCP: Cursor, ChatGPT, Claude ou Claude Code. Os mesmos dados e os mesmos IDs estão disponíveis em todos os lugares.

**Local primeiro.** Todos os dados residem em arquivos SQLite e locais. Não há dependência da nuvem nem telemetria. Você pode verificar tudo o que o sistema faz.

[Neotoma](https://neotoma.io) está adiantado. É uma [versão do desenvolvedor](/posts/neotoma-developer-release): somente local, primeiro CLI, com resolução de entidade heurística, evolução manual de esquema e sem UI da web. O que ele fornece é o contrato, e o argumento é que este contrato é necessário para agentes que lidam com o estado contínuo, e que a recuperação por si só não pode fornecê-lo.

O campo está convergindo para a memória estruturada. A questão é quem constrói a camada em que você confia com seus dados e quais garantias ela oferece. Quero que essa camada seja estruturada desde o início, e não fixada depois do fato. Local primeiro, aberto, inspecionável e sob o controle do usuário.