Agent Memory Below the Prompt: Persistent Q4 KV Cache for Multi-Agent LLM Inference on Edge Devices

Este artigo apresenta um sistema para inferência de LLMs multiagentes em dispositivos de borda que persiste caches KV quantizados em 4 bits no disco, permitindo a restauração direta do estado de atenção e reduzindo drasticamente o tempo de geração inicial enquanto otimiza o uso de memória RAM.

O essencial

Imagine que você tem um assistente de IA superinteligente no seu computador (como um MacBook Pro), pronto para ajudar você a escrever, programar ou debater. Agora, imagine que você não tem apenas um assistente, mas uma equipe de 10 especialistas trabalhando juntos.

O problema é que o computador tem uma "memória de trabalho" (RAM) limitada. É como se você tivesse uma mesa de escritório muito pequena. Se cada especialista precisar de uma pilha de papéis (o histórico da conversa) para lembrar o que foi dito, a mesa enche rapidamente.

Se a mesa encher, você é forçado a jogar os papéis de um especialista no chão (evitar a memória) para fazer espaço para o próximo. Quando você precisa daquele especialista de volta, você tem que:

1. Parar tudo.
2. Ler todos os papéis do chão, um por um.
3. Reescrever tudo na mesa do zero.

Isso leva 15 segundos para cada troca. Em uma equipe de 10 pessoas, isso significa que você passa a maior parte do tempo apenas esperando a IA "lembrar" quem ela é e o que foi dito. É como se o seu time de futebol parasse a cada 5 minutos para o jogador sair do campo, correr até a arquibancada pegar a camisa, voltar e só então começar a jogar de novo.

A Solução: O "Diário de Bordo" Inteligente

Os autores deste artigo criaram um sistema chamado Agent Memory Below the Prompt (Memória do Agente Abaixo do Prompt). A ideia é simples, mas genial:

Em vez de jogar os papéis no chão, você os coloca em uma gaveta rápida (o disco SSD) e os guarda em um formato super compacto.

Aqui está como funciona, usando analogias do dia a dia:

1. A Compressão Mágica (Quantização Q4)

Normalmente, os "papéis" (os dados da memória da IA) são escritos em letras grandes e coloridas (formato FP16). Ocupam muito espaço.
O sistema deles usa uma "caneta mágica" que reescreve tudo em letras minúsculas e em preto e branco (formato Q4, 4 bits).

• Resultado: A mesma quantidade de informação ocupa 4 vezes menos espaço.
• Analogia: É como transformar uma pilha de 100 folhas de caderno em um único caderninho de bolso. Agora, você consegue guardar 12 especialistas na mesma mesa onde antes cabiam apenas 3.

2. O "Diário de Bordo" Persistente

Quando o computador desliga ou a memória enche, em vez de apagar a memória, o sistema salva esse "caderninho de bolso" no disco rígido (SSD).

• O Truque: Quando você precisa daquele especialista de volta, o sistema não precisa reescrever tudo do zero. Ele apenas lê o caderninho e coloca na mesa.
• Velocidade: Ler o caderninho leva 0,5 segundos. Reescrever do zero levava 15 segundos. É uma diferença de 30 vezes mais rápido!

3. O "Efeito Caminhão" (Interleaving)

Você pode pensar: "Mas e enquanto eu estou lendo o caderninho do Agente B, o Agente A não fica esperando?"
Não! O sistema é inteligente.

• Enquanto o Agente A está falando (gerando a resposta), o Agente B está lendo seu caderninho no fundo.
• É como um caminhão de entregas: enquanto o motorista entrega a encomenda (o Agente A falando), o ajudante já está carregando a próxima caixa no caminhão (o Agente B carregando a memória). O tempo de espera é "escondido" pelo tempo de trabalho.

Por que isso é importante para você?

1. Privacidade Total: Tudo acontece no seu computador. Nada é enviado para a nuvem. Seus dados de conversas privadas ficam seguros no seu próprio disco, sem risco de vazamento.
2. Equipes Reais: Permite que você tenha uma equipe de 10, 20 ou até 30 agentes de IA trabalhando juntos no seu computador pessoal, algo que antes era impossível porque a memória acabava.
3. Resposta Instantânea: A IA não demora para "acordar". Ela já sabe o que foi dito antes, mesmo que você tenha desligado o computador e ligado de novo.

Resumo da Ópera

Imagine que a IA é um ator de teatro.

• O jeito antigo: Toda vez que o ator saía do palco para trocar de figurino, ele tinha que ler o roteiro inteiro de novo antes de voltar. O show parava.
• O jeito novo: O ator tem um "teleprompter" (o caderninho compacto) que ele guarda nos bastidores. Quando ele volta, ele só precisa olhar o resumo do que já aconteceu. O show continua fluindo, rápido e sem interrupções.

Os autores provaram que isso funciona em três tipos diferentes de modelos de IA (Gemma, DeepSeek e Llama) em computadores comuns, reduzindo o tempo de espera de dezenas de segundos para menos de meio segundo. É como transformar um computador lento e travado em uma máquina de superpoderes para equipes de IA.

Resumo técnico

Título: Memória de Agente Abaixo do Prompt: Cache KV Persistente Q4 para Inferência Multi-Agente de LLM em Dispositivos de Borda

Autor: Yakov Pyotr Shkolnikov
Data: Fevereiro de 2026

---

1. O Problema: Gerenciamento de Memória em Dispositivos de Borda

O artigo identifica um gargalo crítico na execução de sistemas multi-agente com Grandes Modelos de Linguagem (LLMs) em dispositivos de borda (como laptops Apple Silicon com memória unificada):

• Limitação de RAM: Dispositivos de borda possuem memória RAM fixa e soldada (ex: 24 GB em um MacBook Pro M4 Pro). Após alocar pesos do modelo e o sistema operacional, resta pouco espaço para o KV Cache (Cache de Chave-Valor) necessário para manter o contexto de múltiplos agentes.
• Ineficiência de Troca (Eviction): Em cenários multi-agente (ex: 10 agentes), é impossível manter todos os caches na memória simultaneamente. Quando um agente é "evitado" (removido da RAM) e precisa ser reativado, o sistema tradicional deve recalcular todo o prefill (processamento inicial do contexto) do zero.
• Latência Inaceitável: Em um dispositivo M4 Pro, recalcular o prefill para um contexto de 4K tokens leva cerca de 15,7 segundos por agente. Para um fluxo de trabalho com 10 agentes, isso resulta em tempos de inatividade (dead time) de mais de 2 minutos apenas para reativar os agentes, tornando a interação interativa impossível.
• Falha de Soluções Atuais: Sistemas como vLLM e SGLang, otimizados para datacenters com GPUs massivas, dependem de caches FP16 (precisão simples) que ocupam muito espaço. Em borda, o FP16 não consegue suportar múltiplos agentes simultaneamente sem esgotar a memória, e caches voláteis são perdidos ao reiniciar o servidor.

2. Metodologia e Arquitetura do Sistema

O sistema proposto, chamado agent-memory, resolve o problema através da persistência do estado de atenção (KV Cache) em disco, utilizando quantização agressiva para reduzir o tamanho dos dados.

Componentes Principais:

1. Pool de Blocos Persistente (Persistent Block Pool):

   • Divide o KV Cache em blocos fixos de 256 tokens.
   • Cada agente possui seu próprio cache isolado, armazenado no disco em formato safetensors.
   • Isso permite que o cache sobreviva a reinicializações do servidor e trocas de modelo, atuando como uma "memória virtual" para o estado de atenção.

2. Pipeline de Quantização Q4 (4-bit):

   • O cache é salvo e carregado no formato Q4 (4 bits), reduzindo o tamanho da memória em 72% em comparação ao FP16.
   • A arquitetura usa pesos empacotados (uint32) com escalas e vieses (bfloat16) por grupo.
   • O sistema opera diretamente sobre tensores Q4 na camada de atenção, eliminando a necessidade de desquantização completa antes do cálculo.

3. BatchQuantizedKVCache:

   • Implementa inferência em lote sobre caches quantizados de múltiplos agentes.
   • Utiliza um agendador intercalado (interleaved scheduler) que alterna entre prefill (em chunks) e decode de diferentes agentes, permitindo que a latência de carregamento de um agente seja "escondida" atrás da geração de tokens de outro.

4. Injeção de Contexto Cross-Phase:

   • Permite que o cache acumule estado entre fases de uma conversa (ex: negociação, debate) sem recalcular o prefixo já processado, tratando o cache como "memória de trabalho" persistente.

3. Contribuições Chave

1. Persistência de Cache com Isolamento por Agente: Um pool de blocos que mantém caches Q4 isolados em disco, sobrevivendo a reinicializações e evitando corrupção de estado entre agentes.
2. Inferência em Lote Quantizada (Q4): Implementação de BatchQuantizedKVCache que permite inferência concorrente de múltiplos agentes usando caches quantizados, algo não suportado nativamente por bibliotecas MLX anteriores.
3. Redução de Latência via I/O: Substituição do custo computacional $O(n)$ do prefill por um custo de I/O (leitura de disco) de sub-segundo.
4. Avaliação Multi-Arquitetura: Validação em três arquiteturas distintas:
   • Gemma 3 12B: GQA densa com atenção híbrida (janela deslizante).
   • DeepSeek-Coder-V2-Lite 16B: MoE (Mistura de Especialistas) com MLA (Atenção Multi-Latente).
   • Llama 3.1 8B: GQA densa padrão.

4. Resultados e Desempenho

Os testes foram realizados em um MacBook Pro M4 Pro (24 GB RAM, ~10,2 GB disponíveis para cache).

• Redução de TTFT (Time-To-First-Token):

  • A restauração de cache quente (warm) reduz o TTFT em até 136x comparado ao prefill frio.
  • Exemplos:
    • Gemma 3 (32K tokens): De 172s para 1,3s.
    • DeepSeek (32K tokens): De 47,3s para 624ms.
    • Llama 3.1 (16K tokens): De 47,6s para 526ms.
  • O carregamento de disco (warm) ocorre em ~500ms, cruzando o limiar de 1 segundo para interatividade aceitável.

• Capacidade de Agentes (Memória):

  • O formato Q4 permite armazenar 4x mais agentes na mesma memória em comparação ao FP16.
  • Em 8K de contexto: FP16 suporta 3 agentes; Q4 suporta 12 agentes.
  • Em 16K de contexto: FP16 não consegue suportar nem um único fluxo multi-agente completo; Q4 suporta 6 agentes.

• Qualidade (Perplexidade):

  • A quantização Q4 introduz um impacto mínimo na qualidade do modelo:
    • Gemma 3: -0,7% (dentro do ruído de medição).
    • Llama 3.1: +2,8% de perplexidade.
    • DeepSeek: +3,0% de perplexidade.
  • Esses valores são consistentes com a literatura de quantização de KV cache e considerados toleráveis para ganhos massivos de latência e capacidade.

• Comparação com vllm-mlx:

  • O vllm-mlx (usando FP16) falha em cenários de pressão de memória multi-agente, exigindo isolamento de servidor por contexto e sofrendo eviction (expulsão) de cache mesmo em testes isolados.
  • O sistema proposto mantém a latência baixa mesmo após reinicializações do servidor, algo que o vllm-mlx não consegue fazer (pois seu cache é volátil).

5. Significado e Implicações

• Viabilidade de Agentes Locais: O trabalho torna viável a execução de fluxos de trabalho complexos com múltiplos agentes em dispositivos de consumo (laptops, tablets) sem depender de nuvem, garantindo privacidade de dados (GDPR/HIPAA) e latência previsível.
• Mudança de Paradigma: Transita o gerenciamento de memória de LLMs de um problema puramente computacional (recalcular tudo) para um problema de gerenciamento de I/O (carregar do disco), aproveitando a alta velocidade de SSDs modernos em relação à largura de banda de memória.
• Arquitetura Agnóstica: O sistema abstrai diferenças arquiteturais (GQA vs. MLA, janelas deslizantes vs. globais) através de uma especificação de cache (ModelCacheSpec), permitindo suporte a diversos modelos com a mesma infraestrutura.
• Custo de Desenvolvimento: O artigo destaca o uso intensivo de IA para desenvolvimento (pair programming), onde o custo de API foi baixo (~$200 reais) devido ao uso extensivo de caching de prompts, gerando um código robusto com testes integrados.

Conclusão

O sistema agent-memory resolve o dilema fundamental da inferência multi-agente em borda: a escassez de memória RAM. Ao persistir caches KV quantizados em disco e utilizá-los diretamente na inferência, o sistema elimina a penalidade de latência de recálculo, permitindo que agentes "esquecidos" sejam reativados em milissegundos. Isso transforma dispositivos de borda em plataformas viáveis para orquestração de agentes autônomos complexos, mantendo a privacidade dos dados e reduzindo custos operacionais.

O código-fonte é aberto e disponível em: https://github.com/yshk-mxim/agent-memory.