Paper · Google Research · fev/2026

E se a IA pudesse salvar checkpoints da própria memória enquanto lê?

É exatamente isso que o Memory Caching (MC) faz com redes recorrentes (RNNs): dá a elas uma memória que cresce com o contexto — empatando com Transformers em contexto gigante e tarefas de recall, mas sem o custo quadrático que faz a conta explodir.

Ali Behrouz · Zeman Li · Yuan Deng · Peilin Zhong · Meisam Razaviyayn · Vahab Mirrokni — mesmo time do Titans

🐇 RNNs

Rápidas e baratas (custo O(L)), mas têm amnésia: comprimem tudo num estado de memória de tamanho fixo e esquecem o passado distante.

🐢 Transformers

Lembram de tudo (memória que cresce com o contexto), mas processam cada token contra todos os outros → custo quadrático O(L²) que explode.

⭐ A sacada em uma frase

Em vez de uma memória rígida, a RNN faz um cache dinâmico enquanto lê: salva checkpoints da memória a cada pedaço da sequência, e na hora de responder a própria IA escolhe ativamente quais memórias importam mais. Resultado: custo O(N·L), um meio-termo ajustável entre os dois mundos.

O ponto de partida

Dois extremos, dois problemas

Quase tudo de ponta nos últimos anos (GPT, Claude, Gemini) é construído sobre a mesma arquitetura: o Transformer. Ele é poderoso porque a atenção funciona como uma memória associativa que cresce com o contexto. Mas esse crescimento tem um preço.

🐢 Transformer (atenção)

MemóriaCresce com o contexto (guarda todo token)

RecallExcelente — acessa qualquer token

CustoQuadrático O(L²) + KV-cache estoura

VereditoPreciso, porém caro em contexto longo

🐇 RNN moderna

MemóriaEstado de tamanho fixo (comprime tudo)

RecallFraco em sequência longa — "amnésia"

CustoLinear O(L) — rápida e barata

VereditoEficiente, porém esquece o passado

As RNNs modernas — linear attention, RWKV, RetNet, DeltaNet, Titans — voltaram à moda justamente por serem baratas. O calcanhar de Aquiles é a capacidade fixa: conforme a sequência cresce, a memória sobrescreve o passado. Em tarefas que exigem recuperar uma informação específica de um documento longo (recall-intensive), elas perdem feio pro Transformer.

💡 A pergunta do paper

Dá pra manter o custo barato da RNN e dar a ela uma memória que cresce, como a do Transformer? A resposta é: sim, com um meio-termo controlável.

A solução

Memory Caching: um "botão de salvar" pra memória

1. Fatiar a sequência em segmentos A entrada é quebrada em N segmentos (S¹, S², … Sᴺ). Cada segmento é comprimido por uma memória recorrente, como numa RNN normal.

2. Salvar um checkpoint por segmento Ao fim de cada segmento, o modelo salva uma cópia do estado da memória (o hidden state). Isso é o "cache de memória".

3. Ler de duas fontes ao gerar Cada token (a query) consulta a memória online (a atual, do segmento corrente) e todas as memórias em cache dos segmentos passados.

4. Agregar Uma função de agregação combina tudo: y_t = Agg(memórias em cache ; memória online ; q_t)

O efeito é que a memória efetiva passa a crescer com o tamanho da sequência — em vez de ficar presa num tamanho fixo. A RNN ganha acesso direto a "fotos" comprimidas de todo o seu passado.

Cada token consulta sua memória online + todos os checkpoints em cache do passado (Figura 1 do paper).

💡 Analogia

É como anotar resumos enquanto lê um livro. A RNN pura tenta guardar o livro inteiro numa única foto mental (e esquece). O Transformer relê o livro inteiro toda vez (caro). O Memory Caching anota um resumo por capítulo e consulta só os resumos relevantes quando precisa.

O trade-off

Um dial entre RNN e Transformer

A complexidade do Memory Caching é O(N·L), com 1 ≤ N ≤ L. O número de segmentos N é literalmente um botão de ajuste entre os dois extremos:

RNN puraO(L)

Memory CachingO(N·L)

TransformerO(L²)

N=1 · 1 segmento · compressão total · mais barato N=L · 1 token por segmento · recall máximo

A segmentação controla o equilíbrio entre compressão (recall) e custo:

Segmentos de tamanho constante C → custo ~O(L²/C): parecido com Transformer, mas com uma constante menor (mais eficiente). Foi o que deu melhores resultados.
Segmentos logarítmicos → custo O(L·log L): bem mais eficiente, mas perde resolução do passado distante (pior em tarefas de recall puro).

⭐ Insight que muda a perspectiva

A própria atenção é um caso extremo de Memory Caching (segmento = 1 token). E os modelos híbridos (atenção intercalada com RNN, tipo Samba) também são um caso particular. Ou seja: o paper não inventa um terceiro mundo — ele revela que RNN, Transformer e híbridos são pontos do mesmo espectro, e dá um jeito de escolher onde sentar.

Os sabores

As 4 variantes de agregação

A diferença entre elas está em como combinar as memórias em cache (a função Agg). Da mais simples à mais sofisticada:

➕ Residual Memory

A mais simples: soma as saídas de todas as memórias em cache + a online. Age como um operador de retenção que melhora o acesso ao passado. Para memória estritamente linear ela "colapsa" num estado fixo — mas mesmo assim ajuda na prática.

🎚️ Gated Residual Memory ⭐ melhor acurácia

Usa gates dependentes do input (γ) que pesam quão relevante cada segmento em cache é pro token atual. O gate é a similaridade entre uma projeção do token e o contexto do segmento (mean-pooling + softmax). É aqui que a IA escolhe ativamente o que importa. Não colapsa nem com memória linear.

🍲 Memory Soup

Em vez de combinar as saídas, interpola os parâmetros (pesos) das memórias em cache numa rede customizada por token ("weight souping"). Cada token monta a própria rede de recuperação. Igual ao GRM pra memória linear; diferente pra memória profunda (Titans/DLA).

⚡ Sparse Selective Caching ⚡ mais eficiente

Um roteador estilo Mixture-of-Experts (MoE) seleciona só os Top-k segmentos mais relevantes pra cada token. Carrega só o necessário → baixo overhead, paralelizável e escala pra sequências ultra-longas. Melhor relação custo/benefício.

💡 É genérico

O Memory Caching não é uma arquitetura nova — é uma técnica que pluga em qualquer RNN. No paper foi aplicado em Linear Attention, SWLA, DLA e Titans, sempre melhorando o original.

As evidências

Funciona? Os números dizem que sim

Language modeling & raciocínio (modelos 1.3B, 100B tokens)

Acurácia média em tarefas de commonsense. O +GRM melhora todas as RNNs base — e o Titans+MC chega a superar o Transformer e o híbrido Samba.

Modelo	Acurácia média	Ganho
Transformer++	53.19	—
Samba (híbrido)	54.46	—
SWLA	52.55	—
SWLA + GRM	54.60	+2.05
DLA	53.72	—
DLA + GRM	55.96	+2.24
Titans (LMM)	56.82	—
Titans + GRM	58.33	+1.51

Needle-in-a-Haystack — recall em contexto longo

Achar uma "agulha" (número, UUID) escondida num contexto enorme. Aqui o salto é dramático:

Tarefa	Modelo base	base	+ GRM
S-NIAH-2 (número, 16K)	Titans	75.4	88.2
S-NIAH-2 (número, 16K)	DLA	28.2	54.8
S-NIAH-3 (uuid, 8K)	Titans	42.8	69.0

In-context retrieval — fechando o gap com o Transformer

Aqui o Transformer ainda lidera (média 41.0), mas o Titans+GRM chega a 40.50 — praticamente empata, e fica muito acima da RNN base.

Modelo	Média retrieval
Transformer	41.00
Titans + GRM	40.50
DLA + GRM	38.03
Titans (base)	31.75
DLA (base)	30.51

📈 GRM

Melhor acurácia consistente em todos os benchmarks.

⚡ SSC

Quase tão barato quanto a RNN base; muito mais barato que o Transformer em contexto longo.

⚖️ Eficiência

MC é o meio-termo real — "o melhor dos dois mundos" conforme o contexto cresce.

A parte prática

Como a gente usa isso?

⚠️ Antes de tudo: o que isso é (e o que não é)

Memory Caching é uma técnica de arquitetura, em nível de pesquisa. Não é uma biblioteca pronta com pip install (é um paper do Google Research, sem código público mencionado). Então "usar" aqui significa incorporar a ideia num modelo, não baixar um pacote.

1. Treinando/fine-tunando seu próprio LLM sub-quadrático

Adicione uma camada de memory caching em cima do seu bloco de linear-attention/RNN. Escolha a variante pela necessidade:

GRM → quando você quer máxima acurácia em tarefas de recall.
SSC → quando o foco é contexto muito longo e eficiência.

2. Como truque pós-treino (sem re-treinar!)

O paper mostra que dá pra, na inferência, cachear o estado da memória a cada segmento e usar uma média móvel dos caches. Isso já estende o contexto efetivo e melhora a extrapolação de comprimento de uma RNN já treinada. É o caminho de menor esforço pra colher benefício.

3. O tamanho do segmento é a sua alavanca

É o dial custo↔recall: segmento pequeno = mais recall, mais custo; segmento grande = mais barato, mais esquecimento. Ajuste conforme o orçamento de latência/custo do seu produto.

4. Modelo mental pra decidir arquitetura

Pare de pensar em "RNN vs Transformer". Pense num espectro único de caching e escolha o ponto certo: precisa de recall cirúrgico e tem orçamento? Mais perto do Transformer. Precisa de inferência barata/on-device? Mais perto da RNN, com MC pra não perder o passado.

5. Pro produto

Viabiliza entendimento de contexto longo (recuperação tipo RAG, documentos longos, agentes com histórico longo) por uma fração do custo do Transformer — especialmente relevante pra inferência barata e cenários on-device.

⚠️ Ressalvas honestas

• Os ganhos foram demonstrados em escala acadêmica (760M e 1.3B de parâmetros), não em modelos de fronteira.
• Transformers ainda vencem no recall in-context puro — o MC fecha o gap, mas não ultrapassa sempre.
• Sem código/lib público: por ora é ideia pra incorporar, não ferramenta pra plugar.

Referência rápida

Glossário & fonte

RNN: Rede neural recorrente: processa a sequência token a token, mantendo um estado de memória que comprime o passado.
Atenção: Mecanismo central do Transformer; compara cada token com todos os outros — funciona como memória associativa que cresce com o contexto.
Complexidade quadrática O(L²): O custo cresce com o quadrado do tamanho da sequência (L). Dobrar o contexto quadruplica a conta.
KV-cache: Cache de chaves/valores que o Transformer guarda na inferência; cresce com o contexto e pesa na memória de GPU.
Memória online vs. em cache: Online = estado atual do segmento sendo lido. Em cache = checkpoints salvos dos segmentos anteriores.
Segmento / checkpoint: Pedaço da sequência (segmento) e a "foto" comprimida da memória salva ao fim dele (checkpoint).
Gating (γ): Pesos dependentes do input que decidem quanto cada memória em cache contribui pro token atual.
MoE / roteador: Mixture-of-Experts: um roteador escolhe um subconjunto (Top-k) de componentes a ativar — no SSC, quais caches consultar.
Recall: Capacidade de recuperar uma informação específica vista antes no contexto.

📄 Fonte

Memory Caching: RNNs with Growing Memory — Ali Behrouz, Zeman Li, Yuan Deng, Peilin Zhong, Meisam Razaviyayn, Vahab Mirrokni (Google Research), 2026. arXiv:2602.24281