What is Spotlight and who developed it?

Spotlight is a novel sparse neural memory architecture introduced by research lab Percepta in October 2026. It decouples an LLM's computational reasoning core (the intelligence module) from its long-term state storage (the memory module) by organizing memory as a continuous 2D spatial lattice of recurrent cells.

How does Spotlight solve the Transformer KV-cache scaling problem?

Standard Transformers suffer from quadratic computational complexity O(T^2) and linear memory growth O(T), requiring the entire KV cache to be loaded from high-bandwidth memory for every generated token. Spotlight maps tokens to continuous 2D coordinates (u, v) and restricts reads and writes to localized patches of recurrent cells via differentiable kernels, achieving strict O(1) per-token compute regardless of sequence length.

How does Spotlight differ from Linear Attention and State Space Models (SSMs) like Mamba?

Linear attention and SSMs compress all past history into a single, fixed-size hidden state vector. While this achieves O(1) inference, it suffers from a catastrophic information bottleneck, failing at exact associative recall or high-capacity multi-key retrieval. Spotlight maintains an expandable 2D grid of recurrent cells that allocates new cells upon first write, providing virtually unbounded storage while preserving O(1) step computation.

What is the role of the Static Intelligence Core in Spotlight?

The intelligence core in Spotlight is a compact neural module (under 100K matrix parameters in minimal implementations) that handles execution semantics, control flow, and coordinate routing. Because the memory is external and structured as a writable 2D lattice, the model can acquire new capabilities, store evolving data, and host runtime environments without updating or fine-tuning its core weights.

How does Spotlight execute code autoregressively within its memory?

Because each cell in the 2D lattice maintains a writable recurrent state that supports key rewrites and localized retrieval, the model can represent program symbol tables, stack frames, and AST execution states across dedicated coordinate regions. Percepta demonstrated hosting an entire Python runtime and package ecosystem inside Spotlight memory, allowing the model to simulate program execution step-by-step without an external sandbox.

How well does Spotlight extrapolate beyond its training context length?

In empirical benchmarks, Spotlight demonstrates robust length generalization up to 16x beyond its training window. Because attention coordinates are normalized and localized to bounded cell neighborhoods, attention entropy does not collapse, and perplexity remains flat across sequences exceeding 1 million tokens.

Percepta Spotlight Deep Dive: Decoupling Intelligence from Memory with 2D Lattice Recurrent States and O(1) Token-Time Compute

Simplified Overview (ELI5)

Written by Abrar Akhunji

Imagine you are hired as the lead detective on a massive criminal investigation spanning 100,000 pages of evidence.

The Problem with Today's AI: Two Bad Choices

Every modern AI model is forced to choose between two fundamentally flawed memory systems:

The Standard Transformer (Llama, Claude, GPT-4): "The Exhausting Desk" Every time the detective wants to write a single word, they must pick up every single page they have ever read, re-scan all of them from page 1 to 100,000, and calculate how each word relates to every other word.
- Result: Incredible precision, but your computer runs out of memory (the dreaded KV-cache explosion), and inference slows to a crawl as the document gets longer ($O(T^2)$ computational complexity).
The Recurrent / Mamba Model: "The Shrinking Notebook" To make things faster, models like Mamba or RWKV give the detective a tiny, fixed-size pocket notebook. As new evidence arrives, the detective scribbles over previous notes.
- Result: Blazing fast, constant-speed writing ($O(1)$), but by page 500, the notebook is a smeared, unreadable blob of ink. The model forgets specific facts, numbers, and code variables.

Percepta's Breakthrough: The "Spotlight" 2D Lattice

Announced in October 2026 by Percepta, the Spotlight architecture completely shatters this trade-off by separating Thinking from Remembering.

Instead of a giant stack of paper or a tiny pocket notebook, Spotlight gives the AI a massive, expandable pinboard organized like a 2D map with GPS coordinates $(u, v)$:

      Traditional Attention (KV-Cache)              Percepta Spotlight (2D Lattice)
      Every token scans EVERY previous token         Every token shines a narrow SPOTLIGHT
                                                     onto exact GPS coordinates (u, v)

      [ Token t ]                                    [ Token t ]
           │                                              │
           ├──> Scans Token 1 (Memory read)               ▼ Coordinates: (u=0.42, v=-0.18)
           ├──> Scans Token 2 (Memory read)          ┌───────────────────────────────────┐
           ├──> Scans Token 3 (Memory read)          │  2D LATTICE OF RECURRENT CELLS    │
           │    ...                                  │  [·] [·] [·] [·] [·] [·] [·] [·]  │
           └──> Scans Token 100,000!                 │  [·] [·] [🔦] [🔦] [·] [·] [·]    │
           (Cost blows up quadratically: O(T^2))     │  [·] [·] [🔦] [🔦] [·] [·] [·]    │
                                                     │  [·] [·] [·] [·] [·] [·] [·] [·]  │
                                                     └───────────────────────────────────┘
                                                     (Only reads 4-9 cells: Constant O(1)!)

How Spotlight Works Under the Hood

The Tiny Brain (Static Intelligence Core): The part of the model that calculates logic, grammar, and arithmetic is tiny (under 100K parameters) and never needs retraining.
The Coordinate GPS: When the model sees a piece of data (e.g., user_id = 94821), it computes a continuous 2D location on the board, say $(u=0.74, v=-0.32)$.
The Narrow Beam (The "Spotlight"): Instead of reading the whole board, it shines a narrow flashlight beam over just a tiny $3 \times 3$ cluster of cells around those coordinates.
Living Cells: Each pin on the board is a tiny recurrent cell that can store, update, or overwrite information on the fly.
Infinite Expansion with Zero Slowdown: As you feed the model millions of tokens, the board simply adds more grid cells. But because the flashlight beam never gets bigger, every single token generates at the exact same lightning-fast speed!

Even more wild: Percepta demonstrated that you can store an entire Python interpreter and its library ecosystem directly inside these memory cells. The model can execute code inside its own memory lattice without needing an external computer!

Let’s dive into the tensor mathematics, continuous coordinate projections, PyTorch implementation, and inference benchmarks that make Spotlight tick.

The 5-Stage Spotlight 2D Lattice Memory Execution Lifecycle

Continuous Coordinate Projection: The token representation is projected via linear transformations into normalized continuous 2D coordinates (u, v) in [-1, 1]^2 for both reading and writing.
Localized Spotlight Kernel Synthesis: A differentiable radial basis function (RBF) evaluates kernel affinity strictly across a localized KxK patch of neighboring lattice anchors, yielding normalized weights.
Constant-Time Neighborhood Read: The query gathers states from the KxK cell neighborhood via weighted dot-product, bypassing the need to scan any historical sequence tokens (O(1) step latency).
Gated In-Place Recurrent State Update: Selected memory cells execute in-place state updates using learned retention gates, writing new information while preserving unrelated spatial lattice regions.
Static Intelligence Output Synthesis: The retrieved state is merged with the static core representations and routed into the next transformer layer with zero KV-cache memory allocation.

Section 4: Empirical Benchmarks & Comparative Scaling

To evaluate the operational performance of Percepta's Spotlight, benchmarks were conducted across 1 Million token sequences, measuring KV-Cache Memory Footprint (GB), Per-Token Generation Latency (ms), Multi-Needle Retrieval Accuracy at 512K context (%), and Key Rewrite Preservation (%).

The comparison pits Spotlight (64x64 Lattice) against Standard Transformer GQA (Llama-3.1 70B style), Titans Neural Long-Term Memory (NLTM), and Mamba-2 State Space Model:

Sequence Memory Architecture Scaling & Retrieval Benchmarks (1M Context)

Comparative evaluation of Percepta Spotlight against standard GQA Attention, Titans NLTM, and Mamba-2 SSM across memory footprint, latency, and long-context precision.

metric	Percepta Spotlight (2D Lattice)	Transformer GQA (PagedAttention)	Titans (Neural Long-Term Memory)	Mamba-2 SSM (Linear Recurrence)
HBM Memory @ 1M Tokens (GB / 10)	4.2	64	8.5	1.2
Decode Latency @ 1M Tokens (ms)	8.4	142	24.6	7.8
Needle Retrieval @ 512K (%)	98.7	99.1	91.2	58.4
Key Rewrite Fidelity (%)	96.4	42.1	84	51.2
Zero-Shot 16x Length Extrap (%)	94.2	21	82.5	66.8

Key Benchmark Insights

Dramatically Bounded HBM Footprint: At 1 million tokens, standard Transformer GQA consumes 640 GB of VRAM solely for KV-cache tensors, requiring multi-node tensor-parallel clusters. Spotlight maintains a fixed 42 GB lattice allocation throughout the entire execution.
Deterministic Step Latency: Decoding latency in standard attention surges from 12 ms at token 1,000 to 142 ms at token 1,000,000. Spotlight sustains a flat 8.4 ms per token, competitive with pure state space models like Mamba-2 (7.8 ms).
Lossless Multi-Key Retrieval: Unlike Mamba-2, which collapses under 512K needle retrieval (58.4%) due to state squashing, Spotlight preserves 98.7% retrieval accuracy, closely matching full uncompressed attention (99.1%).
Key Rewrite Superiority: Standard autoregressive transformers struggle when variables are reassigned in long prompts (42.1% fidelity) because old key-value pairs linger in the attention history. Spotlight’s localized in-place gating updates overwrite stale coordinates directly, achieving 96.4% rewrite fidelity.

Section 5: In-Memory Software Ecosystems: Running Python in Latent Space

Perhaps the most radical capability demonstrated by Percepta is hosting entire software execution environments inside the 2D lattice.

The Virtual Machine Analogy

Because Spotlight features:

Spatial Isolation: Distinct coordinate clusters $[u_1, v_1]$ and $[u_2, v_2]$ do not interfere with each other.
In-Place Mutation: Cell states can increment, rebind, or clear values via gated writes.
Persistent Addressing: Consistent token projections map identical variable names to identical coordinate anchors.

Researchers demonstrated allocating coordinate sectors to serve as virtual execution segments:

Sector A ($u \in [-1, -0.5]$): Lexical Symbol Table (Variable Name $\to$ Memory Value pointer).
Sector B ($u \in [-0.5, 0.0]$): Call Stack & Local Frame Registers.
Sector C ($u \in [0.0, 0.5]$): Heap Memory for complex data structures.
Sector D ($u \in [0.5, 1.0]$): Program Counter & Control Flow Invariants.

When executing a Python script autoregressively, the model does not require an external Docker container or subprocess sandbox. It simulates bytecode execution by updating cell states across these sectors token-by-token, effectively operating as a neural Turing machine with constant-time memory overhead.

Section 6: Systems Engineering & Production Deployment (vLLM / SGLang)

Deploying Spotlight in production inference stacks like vLLM or SGLang requires rethinking memory allocators:

Elimination of PagedAttention Fragmentation: In standard LLM serving, PagedAttention allocates non-contiguous physical blocks to hold token KV states. In Spotlight, the KV allocator is replaced by a static Lattice Block Pool. Memory is pre-allocated per sequence and never dynamically expands or fragments during generation.
Fused Triton Spotlight Kernels: Because reads and writes only access $K \times K$ patches (e.g. 9 or 25 cells), specialized Triton kernels load the target cell states directly into GPU Shared Memory (SRAM), perform the RBF weighting and gated accumulation in registers, and write back to HBM in a single memory transaction.
Multi-Head Spatial Divergence: Different attention heads learn to project into different coordinate subspaces. Head 0 might organize memory syntactically, Head 1 by entity identity, and Head 2 by temporal sequence. This natural spatial specialization prevents memory collisions across complex, multi-turn agent dialogues.

Section 7: Strategic Takeaways for Senior Systems Engineers

The KV-Cache is an Architectural Dead End: Storing raw, uncompressed Key-Value vectors for every generated token cannot scale to multi-day, millions-of-token agent workflows. Continuous spatial addressing provides a mathematically elegant escape hatch.
Decoupling Thinking from Remembering: Separating a tiny, static intelligence kernel from an expandable, writable 2D lattice memory mimics biological neocortical organization far more closely than monolithic Transformers.
Constant Compute is the Non-Negotiable Future: Real-time interactive agents, continuous code execution loops, and autonomous operating systems require predictable, constant-time inference latency. Architectures that cannot deliver $\mathcal{O}(1)$ step guarantees will inevitably be replaced.

With Spotlight, Percepta has provided the blueprint for the next evolutionary leap beyond the standard Transformer: infinite context with finite, deterministic compute. :::