Um LLM com memória que nunca para de crescer — Spotlight, da Percepta, explicado

Ver no idioma original →

Autoria: Prompt Engineer 48 · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: An LLM With Memory That Never Stops Growing - Percepta Spotlight Explained · Canal: Prompt Engineer 48 · 10:23 · Assistir no YouTube

Tópicos: Agentes de IA, Modelos de IA

Resumo

O vídeo apresenta o Spotlight, uma arquitetura de modelo de linguagem que, segundo seus criadores, permite que a memória cresça sem aumentar o custo por token. O método usa endereçamento aprendido para ler e atualizar regiões esparsas de uma memória interna, e é comparado com atenção e modelos de estado fixo em tarefas sintéticas e de linguagem. A demonstração mais marcante executa um interpretador Python dentro do transformer e permite atualizar informações e procedimentos sem alterar os pesos. Os resultados são promissores, mas os modelos são pequenos e os benchmarks foram criados pelos próprios autores.

Pontos-chave

• O Spotlight busca combinar memória crescente com trabalho constante por etapa, evitando reler todo o histórico ou comprimi-lo em um estado de tamanho fixo.
• O acesso à memória é esparso: queries e keys são direcionadas a células próximas em uma grade 2D.
• Em tarefas sintéticas de recuperação e atualização de associações, o Spotlight supera os modelos de estado fixo e, em alguns testes, a atenção.
• Nos testes de contexto longo, o Spotlight mantém alta recuperação ao ser avaliado com sequências muito maiores que as usadas no treinamento.
• Os resultados de modelagem de linguagem em contexto curto são competitivos, mas não mostram uma vantagem consistente em todas as métricas.
• A demonstração inclui um interpretador Python executado dentro do transformer, sem um runtime Python externo.
• O modelo pode carregar pacotes na memória e substituir informações ou funções antigas sem modificar os pesos.
• Os autores demonstram também a execução de um classificador de dígitos cujos parâmetros são carregados da memória.
• O vídeo ressalta limitações: os modelos têm até 670 milhões de parâmetros e os benchmarks são dos próprios autores.

Capítulos

Início	Capítulo	Resumo
00:00	O problema da memória em modelos de linguagem	O vídeo apresenta a proposta do Spotlight e explica as limitações de reler o histórico ou resumi-lo.
02:04	Como funciona o Spotlight	A arquitetura usa endereçamento aprendido e acesso esparso a células de uma memória interna crescente.
04:07	Testes de recuperação e contexto longo	O Spotlight é comparado com outros métodos em tarefas sintéticas, modelagem de linguagem e avaliações com contextos extensos.
07:15	Um interpretador Python dentro do transformer	A demonstração executa programas e carrega seletivamente pacotes usando a memória do próprio modelo.
09:20	Aprendizado contínuo e limitações	O vídeo mostra um classificador carregado da memória e conclui avaliando o potencial e as limitações dos resultados.

Citações

Um modelo cuja memória continua crescendo enquanto o custo de cada token permanece exatamente o mesmo. — 00:00

A memória endereçável aumenta com o comprimento da sequência. — 02:35

O modelo recebe o código-fonte Python como tokens e executa o programa autoregressivamente usando apenas seus próprios pesos e memória. — 07:15

Os pesos não mudaram. — 08:49

A demonstração em Python é uma prova de conceito real, mas o interpretador foi construído manualmente. — 09:52

Conceitos e entidades

• Spotlight (modelo): Arquitetura apresentada no vídeo que usa memória endereçável crescente e acesso esparso.
• Perceptor (empresa): Organização associada ao desenvolvimento do Spotlight e à publicação dos textos de pesquisa mencionados.
• Spotlight Memory (conceito): Memória interna do Spotlight, composta por células que podem ser alocadas e atualizadas.
• Gated DeltaNet (modelo): Modelo de estado fixo usado como baseline nas comparações apresentadas.
• MCAR (conceito): Tarefa sintética de recuperação associativa com múltiplas queries, usada para testar a recordação de pares chave-valor.
• Project Euler (conceito): Conjunto de problemas usado na demonstração de execução de programas dentro do transformer.
• Hugging Face (empresa): Plataforma onde, segundo o vídeo, o modelo de demonstração pode ser encontrado.
• Python interpreter inside a transformer (conceito): Demonstração em que o modelo executa código Python usando seus próprios pesos e memória, sem um runtime Python externo.

Tradução completa (pt-BR)

00:00 Certo. Neste vídeo, vamos analisar uma nova arquitetura de modelo de linguagem da Perceptor chamada Spotlight. E a afirmação é bem ambiciosa: um modelo cuja memória continua crescendo enquanto o custo de cada token permanece exatamente igual. Vale lembrar que estou lendo duas publicações de blog da Perceptor Research, ambas datadas de 2 de outubro de 2026. Uma se chama “Can LMs grow their own capabilities?” e a outra, “Spotlight Memory”. Todos os números deste vídeo vêm dessas duas publicações. O plano é simples. Primeiro, o

00:30 problema; depois, como o Spotlight funciona; em seguida, os testes; e, por fim, a parte que considero mais interessante: um interpretador Python rodando dentro do transformer. Os modelos atuais aprendem muito durante o treinamento e, então, são lançados. Depois disso, o mundo que eles descrevem continua mudando, mas o modelo não. A Percepta trabalha com decision models. Pense em um hospital onde milhares ou até milhões de novos pontos de dados chegam por paciente todos os dias, ou em cadeias de suprimentos que mudam a cada pedido e remessa. Então, o modelo tem duas opções. Ele relê todo o histórico para cada novo

01:01 token, o que se torna proibitivamente caro, ou resume o histórico e acaba perdendo detalhes de que talvez precise mais tarde. Também existem RAG, bases de conhecimento externas e arquivos de skill. Eles ajudam, mas dá para ver que funcionam transferindo a memória para fora do modelo. Um componente separado decide o que buscar, e tudo o que ele busca precisa caber na context window. Então, a ideia da Perceptor é trazer uma memória crescente para dentro do próprio modelo, como parte do projeto. Já existe uma longa linha de pesquisas sobre memória em redes neurais, e ela sempre esbarra na mesma troca. Ou a memória tem um

01:32 tamanho fixo, ou o custo de lê-la aumenta com o comprimento da sequência. Vamos começar pela atenção completa. Ela mantém todos os tokens, então nada se perde, mas cada novo token precisa percorrer todo o prefixo. Assim, processar T tokens exige um número de comparações da ordem de T². Cada token custa mais que o anterior. Depois, temos atenção linear e Gated DeltaNet, cujo custo é linear. Isso é bom. Mas elas comprimem o processamento em um único estado de tamanho fixo, como uma página que é reescrita a cada etapa. Com isso, os detalhes acabam esquecidos. Dá para ver a troca: a atenção tem

02:04 memória crescente, mas custo quadrático. Gated DeltaNet tem custo linear, mas capacidade limitada; e modelos híbridos, como Qwen 3 Next e Kimi Linear, combinam as duas abordagens, mas ainda dependem de atenção de comprimento fixo. A Perceptor diz que o Spotlight supera essa limitação e lista três propriedades que considera importantes: estado crescente, acesso esparso e endereçamento aprendido. Vou explicar uma por uma. Estado crescente significa que a memória endereçável aumenta com o comprimento da sequência. Acesso esparso significa que cada token lê e escreve em um número constante de células de memória a cada etapa. E

02:35 endereçamento aprendido significa que o modelo aprende onde colocar as coisas de ponta a ponta. É assim que funciona. Chaves e consultas são mapeadas para endereços em uma grade 2D de células. Uma chave escreve em uma pequena vizinhança ao redor do seu endereço, e uma consulta lê da vizinhança ao redor do próprio endereço. Cada célula é um pequeno estado recorrente de tamanho fixo. Ela é alocada na primeira escrita naquele endereço, e chaves futuras podem atualizá-la. Assim, alocar uma nova célula acrescenta novo espaço de armazenamento. É assim que a memória cresce, e todas as células compartilham a mesma projeção aprendida e a mesma

03:05 regra de atualização. Assim, o modelo aprende essa regra uma vez, e ela é reutilizada independentemente do tamanho que a memória atingir. Para manter o treinamento viável, eles usam um kernel diferenciável. A atenção usa exp de q transposto k, que compara cada consulta com todas as chaves anteriores. O Spotlight usa uma aproximação disso, com uma função compacta em forma de cúpula. Essa função chega suavemente a zero na borda. Então, em uma dimensão, uma leitura ou escrita toca as três células mais próximas; em duas dimensões, exatamente uma região de 3 × 3. Ou seja, nove

03:36 células. Essa região fixa permanece constante, por mais que o contexto aumente. Por que 2D? Porque, em D dimensões, cada acesso toca 3 elevado a D células. Por isso, eles mantêm o endereço de roteamento em 2D e guardam o conteúdo mais rico em características separadas de alta dimensionalidade, armazenadas em um estado delta dentro de cada célula. Assim, o roteamento decide quais células usar, e o conteúdo determina o que há dentro delas. Na comparação da Perceptor, o custo do Spotlight é da ordem de T dividido por eps. O custo da atenção é T ao quadrado, e o da atenção linear é da ordem de T, mas limitado pelo tamanho e pela precisão do estado.

04:07 Certo. Agora, os testes. Primeiro, os sintéticos. MCAR, recuperação associativa multiconsulta: uma sequência apresenta muitos pares de chave e valor e, mais tarde, pede os valores de volta repetindo as chaves. O Spotlight alcança 0,998 quando é testado com 256 pares, depois de treinar com no máximo 64, e 0,999 com 131.000 pares, o que corresponde a um contexto de 524.000 tokens. Gated DeltaNet alcança 0,142 e, depois, 0,005. Agora, a variante com esquecimento é a interessante. Metade das chaves é

04:38 sobrescrita, e o modelo precisa retornar o valor mais recente. O Spotlight alcança 0,998. A atenção cai para 0,748 porque tanto os valores antigos quanto os novos continuam no histórico. O Spotlight simplesmente atualiza a associação armazenada. No MAD, um conjunto de seis tarefas sintéticas, o Spotlight tem a maior média: 0,787, contra 0,749 para Gated DeltaNet 2, 0,698 para Gated DeltaNet e 0,664 para a atenção. E, no Pathfinder, em que uma imagem de 32 × 32 é

05:08 fornecida como uma sequência de 1.024 pixels, o Spotlight obtém 0,769; Gated DeltaNet 2, 0,705; Gated DeltaNet, 0,701; e a atenção, 0,504. Agora, a modelagem de linguagem real. Eles fazem pré-treinamento com 140 milhões, 280 milhões e 670 milhões de parâmetros no FineWeb, com as linhas de base igualadas em número de parâmetros e contexto de 8K. O Spotlight tem perda menor que a atenção nos três tamanhos. Com 670 milhões, chega a 2,154

05:41 contra 2,203 da atenção. Ele iguala o Gated DeltaNet 2 em 2,155, e o Gated DeltaNet mantém uma pequena vantagem, com 2,142 no LML, que usa contexto curto. Os resultados são comparáveis: média de 33,1 para o Spotlight, 33,8 para o Gated DeltaNet 2, 33,3 para a atenção e 34,1 para o Gated DeltaNet. Não há vitória aí, e a Perceptor diz que contextos curtos não são o cenário em que isso faz diferença. Agora, o principal teste: a agulha no palheiro. Os modelos da tarefa de agulha única

06:12 são treinados apenas com 8K e testados até 128K. Isso é 16 vezes mais longo. O Spotlight alcança de 93% a 100% de recuperação em 128K. Os modelos de estado fixo chegam a, no máximo, 5,6%, e a atenção obtém zero a partir de 16K. Depois, eles fazem uma etapa curta de treinamento com contexto longo de 128K. O Spotlight de 140 milhões passa de 93,4% para 97,8%, e o modelo de 670 milhões permanece em 100%. As linhas de base chegam a, no máximo, 15,6%. Portanto, para elas, esse treinamento extra é

06:44 necessário; para o Spotlight, é opcional. A perda também melhora: com 670 milhões de parâmetros e 128K tokens, o Spotlight obtém 1,44 dinats por token, cerca de 0,1 a menos que as duas linhas de base de estado fixo. E, na classificação TIRA do HELMET, a precisão aumenta de 63% para 85% à medida que os prompts crescem de 8K para 128K tokens. Para ser justo, esses são resultados iniciais. Os modelos são pequenos, com no máximo 670 milhões de parâmetros, e os benchmarks são dos próprios autores, mas

07:15 a tendência é clara. Agora, a segunda publicação de blog — e, sinceramente, esta é a parte de que mais gosto. A Perceptor construiu um interpretador Python dentro de um transformer Spotlight. O módulo de inteligência tem menos de 100.000 parâmetros de matriz. Ele implementa apenas a semântica de execução e o controle da memória. A memória contém o próprio interpretador Python, os pacotes principais, o código do programa e o estado de execução. E vale lembrar: não há um runtime de Python por trás disso. O modelo recebe código-fonte Python como tokens e executa o programa de forma autorregressiva

07:47 usando apenas seus próprios pesos e memória. Isso se baseia no trabalho anterior deles: um computador WebAssembly dentro de um transformer. Você pode testar por conta própria. Está no Hugging Face como perceptor AAI/Spotlight VM. Você o carrega com transformers. Passe print 1+2, e ele retorna 3. Nos problemas 1 a 3 do Project Euler, a taxa de processamento se mantém entre 134.000 e 144.000 tokens por segundo, desde o rastreamento mais curto, de 6,5 milhões de tokens, até o mais longo, de 47,6 milhões. Portanto, o trabalho por etapa permanece constante, por mais tempo que ele execute.

08:19 A Perceptor diz que o trabalho da atenção aumenta com o comprimento do rastreamento e que um estado fixo não consegue armazenar a memória de um programa sem limite de tamanho. Por isso, eles chamam o Spotlight de única arquitetura que combina computação geral com trabalho constante por etapa. Ele também lida com classes, geradores, exceções e recursão com 2.000 chamadas de profundidade. A memória é carregada seletivamente. Um programa que usa sorted containers e math lê apenas o Python principal e esses dois pacotes, deixando o restante da biblioteca inativo. A memória tem mais de 100 milhões de parâmetros, mas cada programa paga

08:49 apenas pelo que ele importa. Agora, a parte que responde ao título — a memória é gravável: dê ao modelo a fonte de um pacote, e ele o grava na própria memória. Essa é a versão deles de pip install. O exemplo deles é um pacote de faixas de imposto de 2023. O modelo o instala e depois o usa para calcular o imposto devido. Então, as faixas são atualizadas para 2025. O modelo sobrescreve as células antigas. Você pergunta de novo, e a resposta muda. Os pesos nunca mudaram, e não se trata apenas de fatos. A atualização também substitui o texto da função antiga. Assim, os procedimentos são

09:20 revisados exatamente como os fatos. Esse é um segundo caminho para continuar aprendendo, além do retreinamento. Depois, no maior exemplo, o modelo executa um classificador de dígitos MNIST, carregando seus pesos da memória em blocos. Esse classificador tem mais parâmetros do que as próprias matrizes de pesos do transformer, e suas previsões coincidem com a implementação de referência em todos os exemplos. Portanto, a capacidade de ler dígitos vem da rede armazenada, não do módulo de inteligência. É isso que a Percepta quer dizer com a inteligência crescendo para além dos pesos. Então, aonde isso nos leva? Modelos que nunca reiniciam,

09:52 nunca compactam e descartam o próprio passado e continuam aprendendo, com métodos armazenados, revisados, combinados e reutilizados como pacotes de software ou como lemas e teoremas da matemática. Minha opinião: os números de recuperação são realmente fortes, e a demonstração em Python é uma prova de conceito de verdade, mas o interpretador foi construído manualmente. Os modelos de linguagem são pequenos, e os benchmarks são do próprio autor. Então, este é um bom começo. Neste vídeo, vimos como o Spotlight mantém o custo constante enquanto a memória cresce, e o que isso torna possível. Tanto as duas publicações do blog quanto

10:23 o modelo estão disponíveis nos links da descrição. Me contem o que acham. Até a próxima.

Transcrição original

[00:00] All right. In this video, we’re going to look at a new language model architecture from Perceptor called Spotlight. And the claim is pretty big. A model whose memory keeps growing while the cost of each token stays exactly the same. Now, mind you, I’m reading two blog posts here, both from Perceptor Research, both dated October 2nd, 2026. One is called, “Can LMs grow their own capabilities?” And the other one is called Spotlight Memory. Every number in this video comes from those two posts. So the plan is simple. First the

[00:30] problem, then how spotlight works, then the tests, and then the part I find the most interesting, which is a Python interpreter running inside the transformer. So today’s models learn a lot during training, and then they ship. After that, the world they describe keeps moving, but the model doesn’t. Percepta works on decision-m. So think of a hospital where thousands or even millions of new data points arrive per patient per day, or supply chains that change with every order and shipment. Now the model has two options. It rereads the entire history for every new

[01:01] token which gets prohibitively expensive or it summarizes the history and then it loses details it might need later. Then there’s rag external knowledge basis and skill files. These do help but you can see that they work by moving the memory outside the model. A separate component decides what to fetch and whatever it fetches has to fit in the context window. So perceptor’s idea is to bring a growing memory inside the model itself as part of the design. Now there’s already a long line of work on memory in neural networks and it always hits the same trade-off. Either the memory has a

[01:32] fixed size or the cost of reading it grows with the sequence length. Let’s look at full attention first. It keeps every token so nothing is lost but every new token has to visit the whole prefix. So processing t tokens takes order ts comparisons. Each token costs more than the last. Then we have linear attention and gated delta cost is linear. So that’s good. But they compress the pass into one fixed size state like one page that gets rewritten at every step. So the details get forgotten. So you can see the trade-off here. Attention has

[02:04] growing memory but quadratic cost. Gated Deltaet has linear cost but limited capacity and hybrids like Quen 3 Next and Kim linear mix the two but still rely on fixed length attention. Perceptor says spotlight escapes this and they list three properties they care about. Growing state, sparse access and learn addressing. Let me go through them one by one. Growing state means the addressable memory increases with sequence length. Sparse access means each token reads and writes a constant number of memory cells at each step. And

[02:35] learned addressing means the model learns where to put things end to end. So here’s how it works. Keys and queries get mapped to addresses in a 2D lattice of cells. A key writes to a small neighborhood around its address and a query reads from the neighborhood around its own. Each cell is a small fixed size recurrent state. It gets allocated on the very first right at that address and future keys can update it. So allocating a new cell adds new storage. That’s how the memory grows and all the cells share the same learned projection and the same

[03:05] update rule. So the model learns that rule once and it gets reused no matter how big the memory becomes. Now to keep this trainable they use a differentiable kernel. Attention uses exp of qranspose k which compares every query with every previous key. Spotlight uses an approximation of that with a compact coqued bump. That bump goes smoothly to zero at its boundary. So in one dimension a read or write touches the three nearest cells and in two dimensions it’s exactly 3x3. So nine

[03:36] cells that fixed region is yaxis stays constant however long the context gets. Why 2D? Because in D dimensions every access touches 3 to the power D cells. So they keep the routing address at 2D and keep the rich content in separate highdimensional features stored in a delta state inside each cell. So the routing decides which cells and the content decides what’s inside them. In perceptus comparison spotlight costs order T over teps. Attention costs T squ and linear attention is order T but limited by state size and precision.

[04:07] Okay. Now the tests first the synthetic ones. MCAR multiquery associative recall a sequence shows many key value pairs and later asks for the values back by repeating the keys. Spotlight gets 0.998 when it’s tested at 256 pairs after training on at most 64 and 0.999 at 131,000 pairs which is a 524,000 token context. Gated Deltanet gets 0.142 and then 0.005. Now the forgetting variant is the interesting one. Half the keys get

[04:38] overwritten and the model must return the latest value. Spotlight gets 0.998. Attention drops to 0.748 because the old and the new values both stay in its history. Spotlight just updates the stored association. On MAD, a suite of six synthetic tasks. Spotlight has the highest mean 0.787 versus 49 for gated delta 2, 0.698 for gated delta, and 0.6644 for attention. And on Pathfinder where a 32x32 image is

[05:08] fed in as a sequence of 124 pixels, spotlight scores 0.769, gated delta net 2 gets 0.705, gated delta net 0.701 and attention gets 504. Now real language modeling they pre-train at 140 million, 280 million and 670 million parameters on fine web au with the baselines matched on parameter count at 8K context. Spotlight has lower loss than attention at all three sizes. At 670 million, it’s 2.154

[05:41] versus 2.203 for attention. It matches gated Deltanet 2 at 255 and gated Deltanet keeps a small lead at 2.142 on LML, which is short context. It’s comparable. 33.1 average for spotlight, 33.8 for gated Delta 2, 33.3 for attention, and 34.1 for gated Delta. No win there and perceptor says the same short context is not where this matters. Now the main test needle in a haststack. The ruler single needle task models

[06:12] train at only 8k get tested up to 128k. That’s 16 times longer. Spotlight reaches 93 to 100% recall at 128k. The fixed state models reach at most 5.6% and attention scores zero from 16k upward. Then they do a short stage of 128k long context training. spotlight at 140 million goes from 93.4 to 97.8% and the 670 million model stays at 100. The baselines reach at most 15.6%. So for them that extra training is

[06:44] required and for spotlight it’s optional. Loss improves as well at 670 million and 128k tokens. Spotlight gets 1.44 dinats per token about 0.1 lower than both fixed state baselines. And on tira classification from helmet accuracy goes from 63 to 85% as the prompts grow from 8k to 128k tokens. Now to be fair these are early results. The models are small 670 million parameters at most and the benchmarks are the author’s own but

[07:15] the direction is clear. Now the second blog and honestly this is the part I like the most. Perceptor built a Python interpreter inside a spotlight transformer. The intelligence module has under 100,000 matrix parameters. It only implements execution semantics and memory control. The memory holds the Python interpreter itself, the core packages, the program’s code, and the runtime state. And mind you, there’s no Python runtime behind it. The model takes Python source as tokens and executes the program auto reggressively

[07:47] using only its own weights and memory. It builds on their earlier work, a web assembly computer inside a transformer. You can try it yourself. It’s on hugging face as perceptor AAI/Spotlight VM. You load it with transformers. Give it print oneplus 2 and it gives you three. Now project oiler problems 1 to 3. Throughput holds at 134,000 to 144,000 tokens per second from the shortest trace of 6.5 million tokens to the longest at 47.6 million. So constant work per step however long it runs.

[08:19] Perceptter says attention’s work grows with the length of the trace and a fixed state can’t hold an unbounded program’s memory. So they call Spotlight the only architecture that combines general computation with constant work per step. It also handles classes, generators, exceptions, and recursion 2,000 calls deep. Memory is loaded selectively. A program that uses sorted containers and math reads only core Python and those two packages and leaves the rest of the library cold. The memory is over 100 million parameters but each program pays

[08:49] only for what it imports. Now the part that answers the title memory is writable give the model a packages source and it writes it into its own memory. That’s their version of pip install. Their example is a tax brackets package for 2023. The model installs it then uses it to compute tax owed. Then the brackets are updated for 2025. The model writes over the old cells. You ask again and the answer changes. The weights never changed and it’s not only facts. The update replaces the old text function as well. So procedures get

[09:20] revised exactly like fax. That’s a second route to continue learning besides retraining. Then the biggest example, the model runs an MNEST digit classifier by loading its weights from memory in chunks. That classifier has more parameters than the transformer’s own weight matrices and its predictions agree with the reference implementation on every example. So the ability to read digits comes from the stored network, not from the intelligence module. That’s what perceptor means by intelligence growing beyond its weights. So where does this go? Models that never restart,

[09:52] never compact away their past and keep learning methods stored once revised, combined, and reused like software packages or like lemas and theorems in mathematics. My take the retrieval numbers are really strong and the Python demo is a real proof of concept, but the interpreter is hand constructed. The language models are small and the benchmarks are the author’s own. So this is a good start. So in this video we have seen how Spotlight keeps cost constant while memory grows and what that makes possible. Both blog posts and

[10:23] the model are linked in the description. Let me know what you think. I’ll see you in the next one.