{"intro": {"group": "Start here", "title": "The question", "md": "# Can a model learn during inference?\n\n**Short answer: yes \u2014 but \"learning\" means four very different things, and only two are deployable today.**\n\nThis app builds your intuition in five steps:\n\n1. **The one-minute version** \u2014 the elevator analogy\n2. **The spectrum** \u2014 four classes of \"learning at inference\", from zero-risk to research frontier\n3. **The mechanisms** \u2014 each with a diagram: what changes, when, what it costs\n4. **Does it work?** \u2014 the measured evidence, with honest caveats\n5. **Can YOU use it?** \u2014 deployment-tier verdict + self-test\n\nEvery claim carries its paper link. Nothing requires trust \u2014 click through.\n"}, "eli5": {"group": "Start here", "title": "Intuition (ELI5 to engineer)", "md": "# Intuition first\n\n## The exam analogy (ELI5)\n\nA model answering questions is like a student taking an open-book exam.\n\n- **No learning at inference** = closed-book exam. The student memorized everything months ago (training). During the exam, memory is frozen.\n- **In-context learning (ICL)** = open-book exam. Nothing is memorized \u2014 the student flips to the right page *while answering*. The \"book\" is your prompt. Fast, safe, forgotten the moment the exam ends.\n- **Test-time training (TTT)** = the student is allowed to *take notes during the exam*, and those notes change how they answer the *next* question. The notes are new parameters (or an updated memory state), created **during** the test, from the test material itself.\n\n<div class='analogy'>The key intuition: <b>there is a spectrum between \"looking something up\" and \"learning it.\"<\/b> Looking up is ICL \u2014 cheap, instant, gone afterward. Learning is TTT \u2014 slower, persists for a while, changes future behavior. Everything in this app is a point on that spectrum.<\/div>\n\n## The engineer's version\n\nDuring inference, a transformer has exactly **three places** where knowledge can live:\n\n```\n 1. FROZEN WEIGHTS        fixed after training. Billions of params. Cannot change\n                          at inference (APIs: shared across tenants; self-hosted:\n                          change = restart-scale event)\n 2. CONTEXT / KV-CACHE    per-request. Grows with tokens. Gone when the request\n                          ends. This is where ICL, RAG results, and long prompts live.\n 3. FAST STATE / ADAPTERS the interesting zone:\n                          - LoRA adapters: small weight deltas, swappable between requests\n                          - TTT hidden state: a small model INSIDE the forward pass\n                            that trains itself on every incoming token\n                          - Titans neural memory: weights updated by \"surprise\"\n```\n\nThe question \"can the model learn during inference?\" is really:\n**which of the three buckets are you allowed to write to, and when?**\n\n## One-sentence answer per bucket\n\n| Bucket | Changes during inference? | Notes |\n|---|---|---|\n| Frozen weights | No (API) / only as restart events (self-hosted) | always been this way |\n| Context / KV | Yes \u2014 that's just prompting | GPT-3 era |\n| Fast state / adapters | Yes \u2014 adapters swap between requests (self-hosted); TTT architectures update state every token | 2024+ research |\n"}, "spectrum": {"group": "Start here", "title": "The four-class spectrum", "md": "# The spectrum: four classes of \"learning at inference\"\n\nEvery mechanism belongs to one of four classes. They differ in **what gets updated**, **when**, and **what it costs**.\n\n```\n RISK / PERSISTENCE SPECTRUM \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500>\n\n  retrieval          context-state          activation-state         parameter-update\n  (RAG lookup)       (ICL / KV cache)       (TTT layers, Titans)     (dynamic eval, per-query FT)\n  ---------------    ---------------        ----------------         ----------------------\n  nothing changes    activations change     a small inner model      real weights get\n  in the model;      (attention reads       trains itself on         gradient updates\n  text comes from    your prompt as         every token; frozen      DURING inference;\n  an external DB     \"temporary weights\")   outer weights stay       persists until overwritten\n```\n\n| Class | What changes | Persists? | Deployable today? | Risk |\n|---|---|---|---|---|\n| retrieval | nothing internal | no | yes, everywhere | ~zero |\n| context-state | activations only | per-request | yes, everywhere | ~zero |\n| activation-state | a small inner model's state, every token | per-request (architectures pretrained for it) | no \u2014 research | medium |\n| parameter-update | real weights via gradient steps | yes, until overwritten | no \u2014 research/self-host experimental | high |\n\n<div class='big'>The field's practical question: <b>how far right can you slide before the\ncosts (compute, forgetting, contamination) outweigh the persistence benefit?<\/b> Deployed\nsystems sit entirely at the left edge today. The research frontier pushes right.<\/div>\n"}, "mech-icl": {"group": "Mechanisms", "title": "ICL = implicit gradient descent", "md": "# Mechanism 1 \u2014 In-context learning IS a gradient step (invisible)\n\n**Class: context-state \u00b7 deployable today \u00b7 zero risk**\n\nThe deepest result here: a single **linear self-attention layer provably implements one step of gradient descent** on a regression loss defined by the examples in your prompt.\n\n- von Oswald et al. (2212.10559): trained linear-attention transformers reproduce the exact weight-update trajectory of GD on in-context examples.\n- Dai et al. (2212.07677): trained transformers act as **mesa-optimizers** \u2014 learning algorithms in the forward pass, with curvature correction *beyond* plain GD.\n\n```\n   YOUR PROMPT                              INSIDE THE MODEL\n   +-----------------+\n   | example 1 -> a  |      attention reads these and\n   | example 2 -> b  |  --> produces activations that are\n   | example 3 -> c  |      mathematically equivalent to\n   | new input  -> ? |      one GD step on examples 1-3\n   +-----------------+\n                            \"temporary weights\" = the activations\n                            gone the instant the request ends\n```\n\n<div class='analogy'>You're not showing the student the answer key \u2014 you're letting them <b>practice three problems<\/b> before the real one. Their brain updates, but only inside the exam hall, and only for this exam.<\/div>\n\n## Why this matters for TTT\n\nThe gradient-descent machinery **already exists inside inference**. TTT architectures make it explicit and persistent: instead of implicit updates on vanishing activations, they perform actual gradient steps on an actual small model whose state survives across tokens.\n\n## Cost\n\nQuadratic prefill attention; KV-cache RAM (~0.5-1 MB/token fp16, mid-size models). Zero gradient compute, zero forgetting risk. **This is the baseline every TTT mechanism must beat to justify itself.**\n"}, "mech-ttt": {"group": "Mechanisms", "title": "TTT layers (state = trained net)", "md": "# Mechanism 2 \u2014 TTT layers: the hidden state IS a neural net\n\n**Class: activation-state \u00b7 research (2024) \u00b7 not deployable on existing models**\n\nSun et al. (2407.04620) make the RNN hidden state itself a **small learnable model** (TTT-Linear or TTT-MLP). The recurrence rule at every token:\n\n```\n   for each incoming token:\n      1. inner model tries to predict a transformation of the token (self-supervised)\n      2. loss = how wrong it was\n      3. take ONE gradient step on the inner model's weights\n      4. output = inner model's view of the token, post-update\n```\n\n```\n   token stream:  x1 --> x2 --> x3 --> x4 --> ...\n                     |      |      |      |\n                     v      v      v      v\n                +-------------------------+\n                |  inner model W (small)  |    W is TRAINED at every step\n                |  W <- W - eta*grad(x_t) |    (\"test-time training\")\n                +-------------------------+\n                     |\n                     v\n                output stream (what the outer transformer reads)\n\n   OUTER weights (projections, update rule): frozen after pretraining\n   INNER weights (W): updated every single token\n```\n\n## Results (self-reported, matched-FLOPs vs Mamba 1.4B)\n\n| Claim | Numbers | Caveat |\n|---|---|---|\n| Perplexity keeps dropping through **32k** context | Mamba plateaus after **16k** | 125M-1.3B scale |\n| Matches Transformer 8k perplexity at ~1.3B | linear complexity retained | TTT-Linear ~ Mamba speed |\n| **Weakness**: multi-token recall collapses | S-NIAH-W@8K: TTT 4.4% vs Titans 85.8%+ | independent (Titans' tables) |\n\n<div class='warnbox'>TTT layers lack an explicit <b>forgetting mechanism<\/b> \u2014 the inner model gets overwritten by every token, so multi-needle recall fails. Gated DeltaNet-style erase operations fix this (the Titans/DeltaNet lineage). \"Learning\" without \"forgetting\" is only half a memory system.<\/div>\n\n## Cost\n\nOne inner-loop forward+backward+update **per token**. Linear overall, but the inner gradient step is memory-I/O expensive (flagged for TTT-MLP). Requires pretraining from scratch \u2014 no drop-in for existing transformers (until In-Place TTT, below).\n"}, "mech-titans": {"group": "Mechanisms", "title": "Titans (surprise-based memory)", "md": "# Mechanism 3 \u2014 Titans: memorize what surprises you\n\n**Class: activation-state \u00b7 research (Google, 2025) \u00b7 not deployable on existing models**\n\nTitans (2501.00663) adds a persistent **neural long-term memory** whose weights update at test time proportional to **surprise** \u2014 the gradient of an associative-memory loss measuring how poorly the current input is already memorized.\n\n```\n   token arrives --> how surprising is it?\n                        |\n        +---------------+-----------------+\n        v               v                 v\n   not surprising   surprising        very surprising\n   (skip / tiny     (gradient step    (gradient step +\n   update)          on memory W_M)    momentum amplifies)\n        |               |                 |\n        +-------+-------+--------+--------+\n                v                v\n         memory W_M updated   attention = short-term memory\n         (long-term, bounded  (standard transformer layers)\n          by decay)\n```\n\n## Results (self-reported, Google; models 340-760M)\n\n| Claim | Numbers | Caveat |\n|---|---|---|\n| Beats TTT/Mamba2/DeltaNet on single-needle RULER | S-NIAH-N@16K: **97.4%** vs TTT 4.4 / Mamba2 0.0 / DeltaNet 5.4 | \"outperforms GPT-4\" is one fine-tuned BABILong setting \u2014 not general capability |\n| Effective context beyond **2M** tokens | needle-in-haystack scaling claims | self-reported |\n| Ablations: momentum + weight decay are load-bearing | removing decay: ppl 27.01->29.04, acc 92.7->85.6 | gains come from gating machinery as much as \"learning\" |\n\n<div class='analogy'>Titans = a student with a <b>notebook that only opens when something doesn't fit what they already know<\/b>. Routine information slides past; surprising facts get written down. The decay term is the notebook having limited pages \u2014 old notes fade so new ones fit.<\/div>\n\n## Cost\n\nExtra memory-module forward + inner-gradient step per token; parallelizable training but per-token state I/O; requires training from scratch.\n"}, "mech-inplace": {"group": "Mechanisms", "title": "In-Place TTT (2026)", "md": "# Mechanism 4 \u2014 In-Place TTT: fast weights for models you already have\n\n**Class: parameter-update \u00b7 research (2026) \u00b7 the bridge to practicality**\n\nThe 2024-2025 TTT architectures required **training from scratch** \u2014 the reason they stayed research. In-Place TTT (2604.06169) changes the game:\n\n- Treats the **final projection matrix of existing MLP blocks** as adaptable fast weights\n- Replaces generic reconstruction with an **NTP-aligned** inner objective \u2014 theoretically grounded, not hand-designed\n- Chunk-wise updates, compatible with context parallelism\n- A **4B pretrained model enhanced in-place** beats baselines on contexts up to **128k**\n\n```\n   YOUR EXISTING PRETRAINED LLM (e.g. 4B)\n   +--------------------------------------+\n   | attention layers          FROZEN     |\n   | MLP block 1:  W_proj  <-- FAST WEIGHT |  <-- chunk-wise gradient\n   | MLP block 2:  W_proj  <-- FAST WEIGHT |      steps during inference\n   | ...                                  |\n   | MLP block N:  W_proj  <-- FAST WEIGHT |\n   +--------------------------------------+\n   no retraining from scratch -- the update rule\n   is learned post-hoc on top of the frozen model\n```\n\n<div class='big'>This is the mechanism to watch: <b>TTT ability added to existing models without retraining<\/b>. If it replicates, the \"requires pretraining from scratch\" objection \u2014 the main barrier to adoption \u2014 dissolves.<\/div>\n\n## Cost\n\nChunk-wise inner gradient steps (cheaper than full-model dynamic evaluation); per-chunk optimizer state; research code only, no production serving integration yet.\n"}, "mech-dyn": {"group": "Mechanisms", "title": "Dynamic evaluation + per-query FT", "md": "# Mechanism 5 \u2014 Dynamic evaluation: gradients on the recent stream\n\n**Class: parameter-update \u00b7 works, but expensive \u00b7 the oldest LLM-era TTT**\n\nKrause et al. (1904.08378, 2019): during deployment, take gradient steps on the model using the **recent text itself** as training data, before predicting the next token.\n\n```\n   deployment stream:  ...text text text [PREDICT HERE] text text [PREDICT]...\n                            |            ^            |         ^\n                            +--- gradient steps on recent window ----+\n                                (real weights update, continuously)\n```\n\n## Results\n\n| Claim | Numbers | Caveat |\n|---|---|---|\n| Transformer-XL SOTA improved | enwik8 **0.99 -> 0.94** bits/char; text8 1.08->1.04 | gains shrink for stronger base models |\n| Mechanistic support (vision TTT) | improvement correlates with main/self-supervised gradient alignment, **r = 0.93** | correlation, not guarantee under shift of the auxiliary task |\n\n## Per-query fine-tuning for LLMs (2024-26)\n\nThe same idea per-request: fine-tune on the user's documents before answering. Works for personalization; costs a backward pass per query; risks **catastrophic interference** with base capabilities if updates accumulate.\n\n## Cost\n\nk backward passes per query; optimizer state per user/stream; ordering sensitivity \u2014 early-stream samples bias later predictions.\n"}, "evidence": {"group": "Evidence", "title": "Does it actually work?", "md": "# Does test-time learning actually work?\n\n**Yes \u2014 narrowly and conditionally.** The strongest replicated pattern: adapting parameters on unlabeled test-time data reliably helps **under distribution shift or long-context memorization**. It does *not* reliably help on standard i.i.d. benchmarks where the base model is already strong.\n\n## The evidence table\n\n| Claim | Numbers | Source | Caveat |\n|---|---|---|---|\n| TTT-layers perplexity keeps dropping through 32k context | Mamba plateaus @16k | 2407.04620 | self-reported; matched-FLOPs protocol is authors' own |\n| TTT matches Transformer @8k, ~1.3B, linear cost | parity claim | 2407.04620 | TTT-MLP memory-I/O unresolved |\n| Titans crushes multi-needle RULER | S-NIAH-N@16K: 97.4 vs TTT 4.4 / Mamba2 0.0 | 2501.00663 | self-reported; small models |\n| Titans ablation: momentum/decay load-bearing | ppl 27.0->29.0 w/o decay | 2501.00663 | gains partly from gating, not \"learning\" |\n| TTT collapses on multi-token recall | 4.4% vs DeltaNet >=85% | 2501.00663 tables | independent-ish (baseline reuse) |\n| Dynamic eval: Transformer-XL SOTA | enwik8 0.99->0.94 bpc | 1904.08378 | gains shrink for stronger models |\n| Vision TTT origin: CIFAR-10-C | >10% avg error reduction; never hurts >0.2% | 1909.13231 | needs GroupNorm; extra passes |\n| Gradient-correlation theory | r = 0.93 across 75 test sets | 1909.13231 | correlation, not guarantee |\n\n<div class='verdict'><b>Test-time learning works when:<\/b> (1) the test distribution differs from training (shift adaptation), (2) long-context memorization where quadratic attention is the alternative, or (3) personalization matters more than generality. <b>It does not (yet) help<\/b> standard short-context tasks \u2014 and its failure modes (forgetting, ordering sensitivity, contamination optics) are real.<\/div>\n"}, "failure": {"group": "Evidence", "title": "Failure modes", "md": "# Failure modes \u2014 what goes wrong\n\n## 1. Contamination optics (\"training on the test set\")\n\nTTT updates parameters using unlabeled test inputs. If any test *labels* leak into the update signal, evaluation is compromised. Even without leakage, reviewers will ask \u2014 papers must prove updates use inputs only. Transductive learning has rules; know them.\n\n## 2. Ordering sensitivity and drift\n\nOnline learners are order-dependent: early-stream samples bias later predictions; error accumulates without a reset mechanism. The vision TTT paper needed sample shuffling to avoid ordering artifacts \u2014 which real streams don't give you.\n\n## 3. Interference within the test-time state\n\nThe inner model is overwritten by every token. Knowledge learned at token 100 can be destroyed by token 200. Titans' answer: momentum + decay. TTT-layers' answer: nothing (hence the multi-needle collapse). Any multi-task test-time learner needs an explicit retention policy.\n\n## 4. Compute multipliers\n\nInner-loop forward+backward per token multiplies FLOPs and breaks hardware assumptions (KV-cache-friendly batching, prefix caching). TTT-MLP is bottlenecked on hidden-state memory I/O, not FLOPs \u2014 a memory-bandwidth problem, which is harder to fix than compute.\n\n## 5. Task-design fragility\n\nThe self-supervised task must share gradient direction with the main task (r = 0.93 measured \u2014 but that's after designing the task well). A badly chosen auxiliary task gives zero or negative gains. Continual TTA methods that minimize entropy alone **collapse to near-random** (2306.05401) \u2014 the objective is the whole game.\n\n<div class='warnbox'>Rule of thumb: <b>if you can't state what your inner loss is and why its gradient aligns with your main task, you don't have a TTT method \u2014 you have a hope.<\/b><\/div>\n"}, "serving": {"group": "Can you use it?", "title": "Serving-stack reality", "md": "# Can you use it? The deployment-tier verdict\n\n## Tier 1 \u2014 API models (OpenAI / Anthropic / Google APIs)\n\n**Weights are frozen and shared across all tenants. Period.**\n\nYou control: prompt/KV-cache (per request or cached prefixes), externalized memory (MemGPT-style tool writes), provider memory features. No gradient updates; adapter selection not exposed. \"Learning\" = in-context examples.\n\n## Tier 2 \u2014 Self-hosted open weights\n\n**The only tier where weights can change during serving \u2014 with constraints:**\n\n| Mechanism | What's possible | Constraint |\n|---|---|---|\n| Multi-LoRA serving (S-LoRA 2311.03285, Punica 2310.18547) | thousands of adapters on one base; per-request adapter selection | swap only **between** requests; bounded pool (--max-loras) |\n| vLLM runtime LoRA updating | hot add/remove via API (VLLM_ALLOW_RUNTIME_LORA_UPDATING) | never mid-sequence; rank/dtype must match |\n| Base-weight hot-swap (hotweights, SwapServeLLM) | versioned weight swaps across GPUs \"with minimal pause\" | **invalidates all prefix caches** \u2014 KV entries are weight-derived; drain batches first |\n| Online gradient updates inside serving | \u2014 | **research territory; no engine exposes it** |\n\n<div class='warnbox'>The KV-cache trap: K/V projections depend on W_K/W_V. Any weight change silently corrupts every cached prefix. There is no free lunch \u2014 weight updates and prefix caching are enemies.<\/div>\n\n## Tier 3 \u2014 Research frontier\n\nTTT-layer architectures make weight updates the *primitive* (every token trains the inner model, linear cost). Test-time RL (TTRL 2025) shows self-improvement on unlabeled test data via majority-vote pseudo-rewards \u2014 but it's an offline loop over test sets, not in-request updates. Open problems: memory-I/O-efficient TTT kernels, training-grade gradients inside serving engines, safe per-user personalization without cross-tenant leakage.\n\n## The agent-harness boundary\n\nFor agent systems (like ours): **memory writes at inference are the practical TTT**. Write path is cheap (append to store, inject into context); consumption requires the memory system. Weight-level TTT would let the *model itself* absorb the correction \u2014 but today's harnesses get ~90% of the benefit from journal + retrieval at ~1% of the risk.\n"}, "quiz": {"group": "Self-test", "title": "Self-test (8 questions)", "md": "# Self-test\n\nAnswer each question, then check. Score 6+ = solid intuition. The quiz lives below \u2014 rendered interactively.\n\n<div class=\"qz\" data-a=\"1\"><h4>1. During a standard API call to a GPT-4-class model, what can \"learn\"?<\/h4>\n<button class=\"opt\">The frozen weights, slightly, via gradients<\/button>\n<button class=\"opt\">Only activations \u2014 attention reads your prompt as temporary weights<\/button>\n<button class=\"opt\">LoRA adapters, swapped mid-request<\/button>\n<button class=\"opt\">The KV-cache, permanently<\/button>\n<div class=\"expl\">API models are frozen and shared. ICL = attention implements an implicit GD-like update on <b>activations<\/b> only (von Oswald 2212.10559). Gone when the request ends.<\/div><\/div>\n\n<div class=\"qz\" data-a=\"2\"><h4>2. What is the core move of TTT layers (2407.04620)?<\/h4>\n<button class=\"opt\">Fine-tune the whole model on the test set before answering<\/button>\n<button class=\"opt\">Make the RNN hidden state a small model trained by one gradient step per token, inside the forward pass<\/button>\n<button class=\"opt\">Retrieve more documents at test time<\/button>\n<button class=\"opt\">Increase attention window to 2M tokens<\/button>\n<div class=\"expl\">The hidden state IS the trained net. Outer weights frozen after pretraining; inner weights update every token (Schmidhuber fast-weights lineage).<\/div><\/div>\n\n<div class=\"qz\" data-a=\"1\"><h4>3. Titans' memory update is driven by\u2026<\/h4>\n<button class=\"opt\">Surprise \u2014 the gradient of how poorly the input is already memorized<\/button>\n<button class=\"opt\">Random sampling of past tokens<\/button>\n<button class=\"opt\">The user's explicit feedback<\/button>\n<button class=\"opt\">A fixed learning-rate schedule<\/button>\n<div class=\"expl\">Surprise-based updates + momentum + decay. Ablations: removing momentum/decay costs real accuracy (92.7 to 85.6), so the gating machinery matters as much as the \"learning\".<\/div><\/div>\n\n<div class=\"qz\" data-a=\"2\"><h4>4. TTT layers' known weakness vs Titans/DeltaNet?<\/h4>\n<button class=\"opt\">They can't handle text<\/button>\n<button class=\"opt\">No explicit forgetting \u2014 multi-token recall collapses (4.4% vs 85.8%+)<\/button>\n<button class=\"opt\">They're slower than full attention at 8k<\/button>\n<button class=\"opt\">They require 10x parameters<\/button>\n<div class=\"expl\">Without an erase/gating mechanism, the inner model is overwritten by every token. DeltaNet-family gated delta rules fix exactly this.<\/div><\/div>\n\n<div class=\"qz\" data-a=\"0\"><h4>5. On a self-hosted vLLM stack, when can you change a LoRA adapter?<\/h4>\n<button class=\"opt\">Between requests (with VLLM_ALLOW_RUNTIME_LORA_UPDATING), never mid-sequence<\/button>\n<button class=\"opt\">Any time, including mid-generation<\/button>\n<button class=\"opt\">Only at server startup<\/button>\n<button class=\"opt\">Only for the first request<\/button>\n<div class=\"expl\">vLLM supports runtime add/remove between requests; the adapter set is fixed per scheduled batch. Mid-sequence changes aren't exposed by any standard engine.<\/div><\/div>\n\n<div class=\"qz\" data-a=\"2\"><h4>6. Why does a base-weight hot-swap invalidate the prefix cache?<\/h4>\n<button class=\"opt\">Cache entries are encrypted with a model-key<\/button>\n<button class=\"opt\">It doesn't \u2014 caches survive updates<\/button>\n<button class=\"opt\">K/V projections depend on the weights; new weights compute different K/V for the same tokens<\/button>\n<button class=\"opt\">Tokenization changes with every checkpoint<\/button>\n<div class=\"expl\">Cached K/V are weight-derived. New weights = different K/V for the same tokens = stale cache = wrong attention. Hence hot-swap systems drain batches and flush caches.<\/div><\/div>\n\n<div class=\"qz\" data-a=\"1\"><h4>7. TTT improvement correlates with\u2026<\/h4>\n<button class=\"opt\">Model parameter count<\/button>\n<button class=\"opt\">Gradient alignment between the self-supervised task and the main task (r = 0.93)<\/button>\n<button class=\"opt\">The amount of test data seen<\/button>\n<button class=\"opt\">Learning-rate size alone<\/button>\n<div class=\"expl\">Sun et al. measured r = 0.93/0.89 across 75 corruption sets, matching their convex theory: positive gradient correlation guarantees loss reduction. Task design IS the method.<\/div><\/div>\n\n<div class=\"qz\" data-a=\"2\"><h4>8. For an agent harness TODAY, the practical form of \"test-time learning\" is\u2026<\/h4>\n<button class=\"opt\">Gradient updates to the base model between tool calls<\/button>\n<button class=\"opt\">TTT-layer architectures deployed in vLLM<\/button>\n<button class=\"opt\">Memory written at inference (journal + retrieval) \u2014 no serving engine exposes weight-level TTT, and journal+retrieval gets ~90% of the benefit at ~1% of the risk<\/button>\n<button class=\"opt\">Fine-tuning per user request on API models<\/button>\n<div class=\"expl\">Write path cheap (append + inject), consumption requires the memory system. Weight-level TTT would absorb corrections into the model itself \u2014 not available on any tier you can buy.<\/div><\/div>\n\n<p class=\"score\" id=\"score\"><\/p>\n\n"}, "refs": {"group": "Self-test", "title": "References", "md": "# References (every paper, linked)\n\n| Paper | arXiv | What it established |\n|---|---|---|\n| Test-Time Training with Self-Supervision | 1909.13231 | vision TTT origin; rotation self-supervision; gradient-correlation theory |\n| Learning to (Learn at Test Time) \u2014 TTT layers | 2407.04620 | hidden state = trained net; linear cost; 32k scaling |\n| Titans: Learning to Memorize at Test Time | 2501.00663 | surprise-based neural memory; 2M context; momentum+decay |\n| In-Place Test-Time Training | 2604.06169 | fast weights for existing pretrained LLMs |\n| In-context learning as implicit GD | 2212.10559 | linear attention == one GD step |\n| Mesa-optimizers / ICL as meta-learning | 2212.07677 | transformers perform GD-like updates in forward pass |\n| Dynamic Evaluation of LLMs | 1904.08378 | per-document online fine-tuning; enwik8 SOTA |\n| S-LoRA: serving thousands of adapters | 2311.03285 | unified paging of KV + adapters |\n| Punica: multi-tenant LoRA | 2310.18547 | SGMV kernels for mixed-adapter batches |\n| Continual TTA entropy collapse | 2306.05401 | entropy-minimization TTA collapses to random |\n| SEAL: self-editing language models | 2506.10943 | self-generated finetuning data at deploy time |\n\n## Sources for serving claims\n\n- [vLLM LoRA docs](https://docs.vllm.ai/en/stable/features/lora.html) \u2014 runtime updating flag\n- [hotweights](https://github.com/strangeloopcanon/hotweights) \u2014 versioned cluster weight swaps\n- [OpenAI Agents SDK guardrails](https://openai.github.io/openai-agents-python/guardrails/) \u2014 overhead accounting pattern\n"}}