[Shubham Saboo](https://x.com/Saboo_Shubham_) (um PM do Google) [código aberto de um agente de memória Always-On](https://github.com/GoogleCloudPlatform/generative-ai/tree/main/gemini/agents/always-on-memory-agent) na semana passada como parte do repositório generative-ai do GCP. [A VentureBeat cobriu isso](https://venturebeat.com/orchestration/google-pm-open-sources-always-on-memory-agent-ditching-vector-databases-for) como um sinal sobre o rumo que a infraestrutura do agente está tomando. É um sistema de memória persistente que funciona 24 horas por dia, 7 dias por semana, como um processo em segundo plano, ingerindo arquivos, consolidando em um cronômetro e respondendo a consultas. Nenhum banco de dados vetorial. Sem incorporações. Apenas um LLM que lê, pensa e grava memória estruturada em SQLite.

O projeto valida algo que venho construindo com o [Neotoma](https://github.com/markmhendrickson/neotoma): memória persistente para agentes é uma necessidade real e crescente. Mas os dois projetos fazem escolhas arquitetônicas opostas. Este post os compara.

## O que é o Agente de Memória Always-On

O projeto é uma implementação de referência criada com [Google ADK (Agent Development Kit)](https://google.github.io/adk-docs/) e [Gemini 3.1 Flash-Lite](https://ai.google.dev/gemini-api/docs/models). Ele é executado como um processo leve em segundo plano com três subagentes especializados: um para ingestão, um para consolidação e um para consulta.

1. **Ingestão.** Um inspetor de arquivos monitora um diretório de caixa de entrada. Coloque um arquivo e o agente o pega. Ele também aceita entrada via HTTP POST. Ele lida com texto, imagens, áudio, vídeo e PDF. O LLM extrai resumos, entidades, tópicos e pontuações de importância.

2. **Consolidação.** Em um cronômetro, o agente de consolidação lê todas as memórias armazenadas, encontra conexões e padrões entre elas, compacta itens relacionados e grava novos insights sintetizados. Isso é executado em segundo plano sem aviso prévio.

3. **Consulta.** Você faz uma pergunta. O agente de consulta lê memórias relevantes e insights consolidados, sintetiza uma resposta e a retorna com citações para registros de memória específicos.

O armazenamento é SQLite. Nenhum banco de dados vetorial, nenhum índice de incorporação. A arquitetura aposta que um LLM pode lidar com a recuperação diretamente em registros de texto estruturado sem a necessidade de pesquisa por similaridade.

## Onde se destaca

**Simplicidade.** Clone o repositório, defina uma chave de API Gemini e execute-o. Observador de arquivos, API HTTP e um painel Streamlit. Dependências mínimas e nenhuma infraestrutura para gerenciar além do processo único. Para desenvolvedores que exploram a memória do agente com Gemini, é o caminho mais rápido para uma demonstração funcional.

**A narrativa "sem banco de dados vetorial".** A remoção do banco de dados vetorial reduz a complexidade operacional e conceitual. Não há modelos de incorporação para escolher, nenhum índice para manter, nenhum ajuste de recuperação. Para implantações em pequena escala, esta é uma simplificação real.

**Consolidação ativa.** A consolidação baseada em temporizador é a parte mais distinta. A maioria dos sistemas de memória são passivos: armazenam coisas, recuperam coisas. Este conecta, compacta e sintetiza ativamente. Ele encontra padrões sobre os quais você não perguntou. Isso ressoa com qualquer pessoa que queira uma “memória que pensa” em vez de uma memória que espera.

## Onde as abordagens divergem

O Always-On Memory Agent e o Neotoma compartilham um objetivo (memória de agente persistente), mas divergem em quase todas as decisões de design. As divergências não são acidentais. Eles refletem diferentes premissas iniciais sobre o que a memória deve otimizar.

### Ingestão automática vs explícita

O observador de arquivos é automático. Tudo o que chega à caixa de entrada é processado. Não há etapa de aprovação, nenhuma validação inicial do esquema, nenhuma confirmação do usuário antes do LLM extrair e armazenar. Neotoma adota a abordagem oposta: nada entra no sistema a menos que um agente ou usuário escreva explicitamente através do MCP. Para anotações pessoais, a ingestão automática é conveniente. Para qualquer coisa que exija privacidade ou conformidade, o controle explícito é o padrão mais seguro.

### Quem decide o que lembrar

Neotoma depende do agente cliente para chamar o armazenamento de memória. O agente com quem você está conversando (ChatGPT, Claude, Cursor) decide o que vale a pena lembrar e como estruturar. Ao concluir que um fato, contato ou tarefa deve persistir, invoca a operação de armazenamento via MCP. A responsabilidade pelo “o que lembrar” fica na camada do agente, no mesmo processo da sua conversa.

O Always-On Memory Agent divide essa responsabilidade entre subagentes especializados. O agente de ingestão decide o que extrair dos arquivos. O agente de consolidação decide o que mesclar e quais conexões traçar. O agente de consulta decide o que retornar. “O que vale a pena lembrar” e “como” são distribuídos entre esses subagentes, que funcionam independentemente da conversa. O usuário não aprova cada decisão. Os subagentes os colocam em segundo plano.

### Extração orientada por LLM versus extração determinística

O Always-On Memory Agent usa o LLM para tudo: extrair entidades, atribuir importância, gerar resumos. Execute a mesma extração no mesmo arquivo duas vezes e os resultados podem ser diferentes. Neotoma usa [extração determinística do primeiro esquema](/posts/truth-layer-agent-memory). A mesma entrada produz as mesmas entidades, os mesmos IDs canônicos, os mesmos relacionamentos. A interpretação opcional do LLM é executada sobre essa camada determinística, e não no lugar dela.

### Consolidação vs verdade imutável

O agente de consolidação decide o que mesclar, quais conexões traçar e o que compactar. Muda a memória ao longo do tempo. Memórias antigas são absorvidas por novos insights sintetizados. Neotoma não consolida. Ele anexa. Toda observação é imutável. A história é originada por eventos. Se você precisar ver o que mudou, quando e por que, a trilha completa está aí. Nada é sobrescrito ou compactado.

### Plataforma única vs plataforma cruzada

O projeto é baseado em Gemini e Google ADK. A memória reside em um arquivo SQLite local acessível apenas por meio desta pilha de agente específica. O Neotoma expõe a memória por meio do MCP, o que significa que as mesmas entidades podem ser acessadas pelo ChatGPT, Claude, Cursor e qualquer outra ferramenta compatível com MCP. Uma camada de memória, vários consumidores.

### Sem procedência vs linhagem completa

Os registros de memória no Always-On Memory Agent contêm resumos e entidades extraídas, mas não remontam ao arquivo, linha ou sessão específica que os produziu. Se uma visão consolidada estiver errada, não há trilha de auditoria a seguir. No Neotoma, cada campo em cada entidade remonta a uma observação de origem. Você pode auditar qualquer fato de onde ele veio.

### Compensações de escala

Sem incorporações ou índice vetorial, o sistema lê registros de texto estruturado diretamente usando o LLM. Isso funciona em pequena escala. À medida que os armazenamentos de memória crescem, a abordagem pode não ser válida. A remoção do banco de dados vetorial não remove o design de recuperação. Ele move a complexidade para a janela de contexto do LLM. Neotoma usa consultas estruturadas sobre entidades digitadas, que são dimensionadas independentemente dos limites de contexto do LLM.

## Substrato vs agente

A distinção mais clara é o papel. O Always-On Memory Agent é um agente. Ele ingere automaticamente, consolida de acordo com um cronograma e sintetiza respostas. Tem seu próprio ciclo de raciocínio. Ele decide o que mesclar, quais conexões desenhar e quando compactar.

Neotoma não é um agente. É um substrato. Ele armazena entidades digitadas com IDs canônicos. Mantém a proveniência. Ele responde a consultas determinísticas. Não decide nada sozinho. Nenhuma ingestão em segundo plano. Sem consolidação automática. Nenhum processamento baseado em temporizador. Os agentes leem e escrevem nele por meio do [MCP](/posts/agentic-search-and-the-truth-layer). O raciocínio acontece na camada de agente. A verdade vive no substrato.

Isso é importante por causa do que acontece quando o agente está errado. Se a consolidação do Always-On Memory Agent produzir um insight ruim, esse insight agora fará parte da memória. Não há nenhuma camada separada para verificação. O agente é a verdade.

Com uma camada de verdade por baixo, você pode rastrear o que o agente leu, quando leu e o que escreveu de volta. Se o novo insight estiver errado, você poderá reverter. A saída do agente de consolidação é uma observação sobre o estado determinístico, e não uma mutação dele.

| Dimensão | Agente de memória sempre ativa | Camada da verdade (Neotoma) |
|-----------|-------------|-----------------------|
| Função | Agente com loop de raciocínio | Substrato sem comportamento de agente |
| Quem decide o que armazenar | Subagentes especializados (ingestão, consolidação) | Agente cliente (via MCP) |
| Ingestão | Automático (observador de arquivos, API) | Somente explícito (MCP, CLI, upload) |
| Extração | Orientado por LLM; probabilístico | Esquema primeiro; determinístico |
| Consolidação | Consolidação LLM baseada em cronômetro | Nenhum; verdade imutável, atualizações provenientes de eventos |
| Proveniência | Básico (fonte/resumo em registros) | Linhagem completa; cada campo rastreia a origem |
| Plataforma | Somente Gêmeos/Google ADK | Multiplataforma via MCP (ChatGPT, Claude, Cursor) |
| Privacidade | Não posicionado como privacidade em primeiro lugar | Controlado pelo usuário; sem acesso de provedor |
| Reversão | Não; memória sofre mutação por consolidação | Sim; somente acréscimo, versionado, reversível |
| Modelo em escala | LLM lê todos os registros; limitado pelo contexto | Consultas estruturadas sobre entidades digitadas |

## Como eles poderiam trabalhar juntos

As duas abordagens não são mutuamente exclusivas. Um agente de consolidação e uma camada de verdade resolvem problemas diferentes. Encontram-se padrões. O outro mantém a confiança. A arquitetura interessante combina ambos.

O esboço é direto. Um agente de consolidação (como aquele do Always-On Memory Agent) lê entidades de uma camada de verdade via MCP. Tem acesso ao estado estruturado completo: entidades digitadas, relacionamentos, cronogramas, proveniência. Ele executa seu ciclo de busca de padrões nesse estado, procurando conexões, lacunas ou insights que o usuário não solicitou. Quando encontra algo, ele grava o resultado de volta na camada verdade como uma nova observação, marcada com suas entidades de origem e raciocínio.

A camada da verdade trata esse insight da mesma forma que trata qualquer outra gravação. Registra-o como uma observação com procedência completa: quais entidades o agente leu, quando, o que concluiu. O insight passa a fazer parte do gráfico da entidade. Se o insight estiver errado, você poderá ver exatamente o que o agente consumiu, rastrear o raciocínio e reverter a observação sem afetar as entidades subjacentes das quais ele leu.

Isso é diferente de como a consolidação funciona hoje no Always-On Memory Agent. Lá, o agente de consolidação altera a memória diretamente. Memórias antigas são absorvidas em novos registros sintetizados. O estado anterior desapareceu. Se a síntese estiver errada, não há nenhuma camada separada para comparar.

Com uma camada de verdade subjacente, a consolidação torna-se uma operação não destrutiva. O agente adiciona uma camada de interpretação sobre o estado determinístico. O próprio estado permanece imutável. Você obtém os benefícios da descoberta de padrões ativos (o ponto forte do Agente de Memória Always-On) com os benefícios da auditabilidade e da reversão (o ponto forte da camada de verdade). Inteligência acima, confiança abaixo.

## O que isso valida

O Always-On Memory Agent é uma implementação de referência, não um produto. O que isso confirma é que a demanda por memória de agente dinâmica e persistente é real. "[Vector DB plus RAG](/posts/why-agent-memory-needs-more-than-rag)" não é o único modelo de recuperação. As [tendências estruturais que impulsionam isso](/posts/six-agentic-trends-betting-on) são claras: os agentes estão se tornando stateful, os erros estão sendo avaliados e as plataformas permanecem opacas. O projeto sinaliza que a indústria está migrando para sistemas de memória sempre ativos que vão além do simples armazenamento e recuperação.

Onde os dois projetos concordam: a memória passiva não é suficiente. Onde eles discordam: se a própria camada de memória deveria raciocinar ou se o raciocínio deveria acontecer em uma camada separada sobre o estado determinístico. Essa é uma questão central na arquitetura de memória do agente no momento. O mercado provavelmente apoiará ambas as abordagens. Espero que a arquitetura possa convergir para agentes de consolidação que pensam, operando sobre camadas de verdade nas quais você pode confiar.

## O que estou construindo

Estou construindo o [Neotoma](https://github.com/markmhendrickson/neotoma) como camada de confiança. Entidades digitadas, IDs canônicos, mesclagem determinística, procedência, acesso multiplataforma via MCP. Eu uso diariamente no ChatGPT, Claude e Cursor. A [versão do desenvolvedor](/posts/neotoma-developer-release) já está disponível em [neotoma.io](https://neotoma.io).

A amostra do Google mostra que a indústria está convergindo para a memória persistente do agente. A questão em aberto não é se os agentes se lembrarão, mas como. Capacidade ou governança. Agente ou substrato. Consolidação probabilística ou verdade determinística. Aposto neste último.