💻 computer science

AMP: A Vendor-Neutral Wire Format for Agent Memory Operations

Este artigo apresenta o memorywire, um formato de fio JSON-Schema neutro em relação ao fornecedor e uma implementação de referência que padroniza as operações de memória de agentes através de diversos frameworks por meio de uma interface unificada, um canal de governança e adaptadores de backend empiricamente validados, visando possibilitar a interoperabilidade sem competir com o Model Context Protocol.

Autores originais: Thamilvendhan Munirathinam

Publicado 2026-06-02

📖 5 min de leitura🧠 Leitura aprofundada

CC BY 4.0

Autores originais: Thamilvendhan Munirathinam

Artigo original sob licença CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Esta é uma explicação gerada por IA do artigo abaixo. Não foi escrita nem endossada pelos autores. Para precisão técnica, consulte o artigo original. Ler aviso legal completo

Imagine que você está construindo uma equipe de assistentes de IA. No momento, cada assistente tem sua própria maneira de lembrar das coisas. Um escreve notas em um diário de couro, outro usa um aplicativo de notas adesivas digitais e um terceiro mantém um memorando de voz. Todos eles falam "línguas" de memória diferentes. Se você quiser mudar o sistema de um assistente para outro, terá que reescrever todo o seu histórico do zero. Pior ainda, se um assistente escrever algo estranho ou perigoso, não há um gerente para verificar antes que isso seja trancado em seu cérebro permanente.

memorywire é uma nova proposta para corrigir esse caos. Pense nisso como um tradutor universal e um sistema de arquivamento padronizado para as memórias de IA.

Aqui está como o artigo divide isso, usando analogias simples:

1. O Problema: A "Torre de Babel" da Memória de IA

Atualmente, as ferramentas de memória de IA populares (como mem0, Letta, Cognee) são como países diferentes com moedas diferentes.

O Problema: Se você quiser mover a memória de uma IA do "País A" para o "País B", não pode apenas transferir o dinheiro; você tem que derretê-lo e cunhá-lo novamente. Você perde detalhes e isso é caro.
O Gerente Ausente: Nenhum desses sistemas possui um "gerente" integrado para revisar o que a IA escreve antes que se torne permanente. É como deixar um aluno escrever no quadro branco da escola sem um professor verificar primeiro se a matemática está correta.

2. A Solução: Um "Fio de Memória" Universal

Os autores criaram o memorywire, que é um formato padrão (uma forma específica de empacotar dados) que qualquer sistema de IA pode entender.

As 5 Ações: Em vez de uma lista bagunçada de comandos, o memorywire define exatamente cinco coisas que uma IA pode fazer com a memória:
1. Lembrar (Remember): Escrever um novo fato.
2. Recordar (Recall): Pedir uma memória.
3. Esquecer (Forget): Deletar uma memória.
4. Mesclar (Merge): Combinar duas memórias semelhantes em uma só (para evitar duplicatas).
5. Expirar (Expire): Deletar automaticamente memórias antigas (como uma data de "validade").
Os 4 Tipos de Memória: Assim como os humanos, o sistema classifica as memórias em quatro baldes:
- Semântica: Fatos (ex: "Alice odeia amendoim").
- Episódica: Eventos (ex: "Alice estava nervosa em seu voo ontem").
- Procedural: Passos de "como fazer" (ex: "Como reservar um voo").
- Emocional: Sentimentos (ex: "Alice sentiu ansiedade sobre voar").

3. O "Guarda de Trânsito": O Roteador (Router)

O artigo introduz um "Roteador" que atua como um guarda de trânsito.

Como funciona: Quando você pede para uma IA "Recordar" algo, o Roteador não pergunta apenas a um banco de dados; ele grita a pergunta para todos os diferentes sistemas de memória conectados a ele ao mesmo tempo.
O Truque Mágico (RRF): O Roteador usa um truque matemático chamado Fusão de Classificação Recíproca (RRF). Imagine três amigos adivinhando um número.
- Se o Amigo A diz "5", o Amigo B diz "5" e o Amigo C (um mentiroso) diz "100", o Roteador confia nos dois amigos que concordam.
- O artigo prova que, mesmo que um dos sistemas de memória seja hackeado ou esteja mentindo, esse truque matemático garante que a IA receba a resposta correta. É como uma rede de segurança que pega o mentiroso.

4. O "Humano no Circuito": O Portão de Aprovação

Este é um recurso importante. O sistema permite um fluxo de trabalho de "Diferença e Aprovação" (Diff-and-Approve).

O Cenário: Uma IA quer escrever uma nova memória: "O usuário é alérgico a amendoim".
O Portão: Em vez de salvar imediatamente, o sistema faz uma pausa. Ele mostra a um revisor humano um "diff" (uma comparação do que é novo versus o que é antigo).
A Decisão: O humano clica em "Aprovar" ou "Rejeitar". Somente então a memória é salva. Isso evita que a IA escreva acidentalmente fatos falsos ou prejudiciais.

5. O Que Eles Realmente Testaram (Os Resultados)

Os autores não inventaram um novo cérebro mágico; eles apenas organizaram as ferramentas existentes melhor. Eles testaram o sistema com:

Velocidade: Foi muito rápido (cerca de 40 milissegundos para lembrar ou recordar algo).
Precisão: Tested with 42 questions, the system found the correct answer 100% of the time in the top 5 results. (An additional 8 trick questions were used to ensure the system didn't hallucinate.)
Segurança: Eles tentaram "hackear" o sistema fazendo um dos bancos de dados de memória mentir. O "Guarda de Trânsito" (RRF) ignorou com sucesso o mentiroso e manteve as respostas corretas.
Compatibilidade: Eles testaram contra 5 sistemas de memória existentes. Funcionou perfeitamente com os que foram construídos sobre bancos de dados padrão (SQLite e PostgreSQL) e funcionou bem o suficiente com os outros, provando que pode falar diferentes "línguas".

O Ponto Principal

O artigo afirma que o memorywire não é um novo tipo de inteligência de IA. É um protocolo padronizado. É a "porta USB-C" para a memória de IA. Ele permite que diferentes sistemas de IA se conectem ao mesmo banco de memória, garante que dados ruins possam ser filtrados por humanos e protege o sistema mesmo se uma parte da rede for comprometida.

Os autores são honestos: eles não estão alegando que esta é a solução final e perfeita. Eles estão lançando isso como um "rascunho" (versão 0) para obter feedback, com o objetivo de torná-lo um padrão que todos adotem, de forma semelhante a como o Model Context Protocol (MCP) está se tornando um padrão para ferramentas de IA.

Resumo Técnico: memorywire – Um Formato de Fio Neutro para Operações de Memória de Agentes

1. O Problema: Estruturas de Memória Isoladas

O cenário atual das estruturas de memória de agentes (ex: mem0, Letta/MemGPT, Cognee, Zep/Graphiti, MemoryOS, MemTensor) é caracterizado pela heterogeneidade. Cada estrutura vem com seu próprio SDK, layout de armazenamento, vocabulário operacional e ciclo de vida implícito para criação e exclusão de registros. Não existe um "formato de fio" (wire format) compartilhado.

Essa falta de padronização cria três problemas primários:

Integração e Migração Sob Medida: Integrar um agente com um novo backend ou migrar entre estruturas requer adaptadores customizados. A perda de dados em nível de campo é comum quando as estruturas de origem codificam mais estado do que o modelo de dados do destino suporta.
Falta de Governança Compartilhada: Nenhuma estrutura fornece atualmente um fluxo de trabalho padronizado de "diff-and-approve" (diferença e aprovação) onde revisores humanos possam auditar escritas antes que elas entrem no armazenamento de longo prazo. Os operadores devem construir camadas de governança customizadas, que podem ser contornadas pelo framework subjacente.
Estagnação Algorítmica vs. Lacunas de Protocolo: O artigo argumenta que os algoritmos principais (busca vetorial, Reciprocal Rank Fusion, FSMs, consolidação STM/LTM) são bem conhecidos. A lacuna não está no desempenho de recuperação, mas na falta de um protocolo compartilhado para compor esses componentes através de diferentes runtimes e backends.

2. Metodologia e Arquitetura

O artigo apresenta o memorywire, um formato de fio neutro ao fornecedor e uma implementação de referência projetada para padronizar as operações de memória de agentes.

2.1 Design do Formato de Fio

O protocolo é definido via JSON Schema 2020-12 e é agnóstico ao transporte (REST, JSON-RPC, etc.). Ele define:

Cinco Operações Principais: remember (escrever), recall (ler), forget (deletar), merge (deduplicar) e expire (aplicação de política de TTL).
Quatro Tipos de Memória: Semântica, Episódica, Procedural e Emocional, extraídos de taxonomias da ciência cognitiva (Tulving, Squire).
Protocolo MemoryStore: Um Protocol Python que define a interface para backends. Os backends declaram capabilities (capacidades) (ex: vector, graph, procedural), permitindo que um roteador componha lojas heterogêneas sem que o chamador precise conhecer as restrições específicas do backend.

2.2 Implementação de Referência

Os autores fornecem uma implementação de referência em Python 3.11+ apresentando:

Cinco Adaptadores de Backend: sqlite-vec, mem0, Letta, Cognee e pgvector. Esses adaptadores mapeiam o formato de fio para seus respectivos modelos de dados internos, lidando com a perda de fidelidade (ex: codificando campos como tags de metadados) onde necessário.
Roteador de Memória: Um roteador de fan-out que executa operações em $N$ $N$ lojas filhas em paralelo.
- Fusão de Recall: Utiliza Reciprocal Rank Fusion (RRF) como algoritmo padrão ( $k=60$ ), que é independente de pontuação e aditivo. Também suporta fusão MAX e weighted (ponderada).
- Boost de Grafo: Um boost de grafo de um salto (one-hop) opcional para itens cujos vizinhos também estão no conjunto fundido.
- Tolerância a Falhas: Utiliza asyncio.gather com return_exceptions=True para garantir que um único backend problemático ou indisponível não derrube toda a operação de recall.
Memória Procedural: Armazena Máquinas de Estados Finitos (FSMs) como blobs serializados em JSON compatíveis com pytransitions, com validação estrita para evitar Execução Remota de Código (RCE) via injeção de callback.
Transformador STM/LTM: Uma tarefa de segundo plano assíncrona que pontua itens de curto prazo baseando-se em recência, saliência e confiança, promovendo-os para o armazenamento de longo prazo ou expulsando-os.

2.3 Canal de Governança

Um recurso chave é o padrão Co-memorize, formalizando um fluxo de trabalho de "diff-and-approve".

Escritas marcadas com approval_required=true são posicionadas atrás de um sentinela (PENDING_APPROVAL_DELETED_AT = -1) e permanecem invisíveis para o recall até que um revisor humano as confirme ou rejeite via uma UI fornecida.
Um log de auditoria de apenas adição (append-only) serve como a única fonte da verdade para toda a governança e eventos de mutação.

3. Principais Contribuições

O artigo apresenta cinco contribuições específicas:

C1. Especificação de Formato de Fio: Um protocolo baseado em JSON Schema para cinco operações sobre quatro tipos de memória, explicitamente versionado com uma política de mudanças disruptivas (breaking changes) até a v0.5.
C2. Implementação de Referência: Um SDK Python pronto para produção com cinco adaptadores de backend, um roteador paralelo usando RRF e um modelo de falha parcial tolerante.
C3. UI de Governança: Uma implementação do padrão diff-and-approve que se integra transparentemente com qualquer adaptador de backend.
C4. Avaliação Empírica:
- Um microbenchmark em 100 fatos/50 consultas.
- Um experimento de fusão adversária testando a robustez contra backends maliciosos.
- Um conjunto de conformidade cross-adapter de 16 cenários.
C5. Modelo de Ameaça e Artefatos: Um modelo de seis adversários com mitigação em nível de linha e artefatos de dados abertos que permitem a reprodutibilidade total de suas alegações.

4. Resultados

4.1 Desempenho de Microbenchmark

Em um corpus de 100 fatos escritos à mão e 50 consultas rotuladas (usando all-MiniLM-L6-v2 e sqlite-vec):

Recall@5: 1.000 em 42 consultas rotuladas (paráfrase, correspondência exata e multi-hit).
Latência: Ingest p50 = 37.8 ms; Recall p50 = 40.6 ms.
Precisão: 0.214 (limitada pela razão de IDs de ouro por consulta).
Tratamento de No-Match: 0/8 sondagens de "no-match" retornaram falsos positivos (embora o artigo note que isso se deve a uma escolha deliberada de design v0 de retornar até $k$ hits sem um limiar de relevância).

4.2 Experimento de Fusão Adversária

O estudo testou a robustez dos algoritmos de fusão contra um "backend malicioso 1-de-N" que injeta IDs controlados pelo atacante no rank 0.

RRF: Manteve Recall@5 = 1.000 em todos os orçamentos de ataque ( $K \in \{0, 5, \dots, 50\}$ ). A independência de pontuação do RRF impede que um único armazenamento malicioso domine o resultado fundido.
MAX: Colapsou imediatamente em $K=5$ , com Recall@5 caindo para 0.500 e uma taxa de vazamento de 80% (80% dos IDs retornados eram controlados pelo atacante).
Weighted: Desempenhou identicamente ao RRF quando os pesos eram iguais.

4.3 Conformidade Cross-Adapter

Um conjunto de 16 cenários invariantes de protocolo foi executado contra todos os cinco adaptadores (80 células totais).

Resultados: 68 PASS, 12 SKIP, 0 FAIL.
Análise: Os adaptadores baseados em SQL (sqlite-vec, pgvector) passaram em todos os cenários. Os adaptadores de embrulho de SDK (mem0, Letta, Cognee) pularam (SKIP) cenários relacionados a funcionalidades ausentes em seus upstreams (ex: falta de namespaces de user_id, falta de IDs estáveis por registro ou falta de guardas de política vazia). Esses skips identificaram áreas específicas para o endurecimento da especificação v0.2.

4.4 Benchmarks Preliminares de Longo Contexto

Execuções preliminares no LongMemEval e LoCoMo mostraram melhoria significativa após corrigir um bug onde o ANN-vetorial top-k era computado antes do filtro do agente:

LongMemEval: Melhorou de 0.286 para 0.417 (+46% relativo).
LoCoMo: Melhorou de 0.018 para 0.150 (+8.3× relativo).
Os autores observam que estes são preliminares (n=10–12, 1 seed) e o embedder (all-MiniLM-L6-v2) é uma referência fraca; o protocolo em si é agnóstico ao embedder.

5. Significância e Alegações

O artigo enquadra explicitamente sua contribuição não como um novo avanço algorítmico, mas como um empacotamento e padronização de componentes estabelecidos (RFF, FSMs, consolidação STM/LTM, fluxos de trabalho de diff-and-approve).

Posicionamento: O memorywire é posicionado para compor com o Model Context Protocol (MCP) em vez de competir com ele. Enquanto o MCP padroniza o uso de ferramentas, ele carece de um primitivo de memória nativo. O memorywire preenche essa lacuna, podendo servir como uma extensão do MCP no futuro ou um padrão independente (via IETF).
Modéstia: Os autores reconhecem que o memorywire v0 é um rascunho com direitos reservados para quebrar a compatibilidade até a v0.5. Eles admitem que a avaliação atual usa corpora sintéticos pequenos e benchmarks preliminares, com avaliações de escala total (5-seed × 200 perguntas) adiadas para uma versão v2.
Valor Central: O principal valor proposto é um protocolo neutro em relação ao local que permite que qualquer cliente fale com qualquer backend, permite que agentes carreguem memória através de runtimes e fornece uma superfície padronizada para governança humana sobre as escritas de memória.

Em resumo, o memorywire oferece um protocolo pragmático e empiricamente validado para resolver a fragmentação de interoperabilidade e governança que atualmente assola o ecossistema de memória de agentes.