Surveys

Test-Time Training: A Survey of Learning at Inference, from Self-Supervision to Memory Layers, LLMs and Agents

Abstract

Test-time training (TTT) lets a model keep learning after deployment: before or while it predicts, it optimizes an explicit learning objective on the test input, the test context, the test problem or the deployment stream, and uses the updated weights for its answer. The idea began in 2019 as a robustness device for image classifiers and has since become one of the organizing ideas of several otherwise separate research lines: sequence architectures whose hidden state is a small model trained online by gradient descent, language models fine-tuned on each test task or on their own long context, reinforcement learning on unlabeled test questions, agents that turn verified experience into weight updates, and robots and world models that adapt to the environment they meet. This survey covers that narrow-sense TTT literature and leaves fully test-time adaptation by entropy minimization, pseudo-labels or normalization statistics as background. It organizes the field along one axis, what is learned at test time and from which signal, into six branches; writes the main methods of every branch in one shared notation; and compares their evidence under stated conditions. Five questions run across the branches: whether TTT layers are more than linear attention, whether test-time memorization trades recall for compression, why test-time RL with self-derived rewards first helps and then collapses, why TTT helps even without distribution shift, and how test-time updates change the safety surface. The corpus was built from 4,820 retrieved candidates screened to 605 papers; 94 were read at section level and the remainder are cited for what their abstracts state. The library cutoff is 4 November 2026.

1 Introduction

A deployed neural network is usually a fixed function. Everything it will ever know is decided by the end of training, and at inference it can only condition on what it sees: a context window, retrieved documents, a prompt. Test-time training breaks that convention in a specific way. The model receives a test instance, constructs a learning problem from it, takes one or more optimization steps on that problem, and only then predicts. The first version of the idea attached a rotation-prediction head to an image classifier and, for each corrupted test image, updated the shared encoder on the rotation loss before classifying . Seven years later the same pattern, an inner learning problem solved inside inference, appears in places its originators did not plan for: in the recurrent state of long-context language models , in a 63-second video generator , in the few-shot solver that brought a language model close to average human accuracy on the Abstraction and Reasoning Corpus , in reinforcement learning on unlabeled competition math and in searches that improved best-known bounds on open mathematical problems .

These lines grew in different communities with different vocabularies. Architecture papers speak of fast weights, delta rules, associative memory and test-time regression; robustness papers of auxiliary tasks and distribution shift; language-model papers of LoRA adapters, context internalization and self-consistency rewards. The shared structure is easy to miss. In each case there is an inner loop that optimizes a loss defined on test-time data and an outer loop, run during training, that decides what that inner loop learns, how fast, and from which signal. The growth of the literature makes a synthesis timely: in the corpus assembled for this survey, papers per year (by first arXiv version) rise from 30 in 2022 and 73 in 2024 to 156 in 2025 and 263 in the first ten months of 2026, and the newest work increasingly borrows across lines (TTT layers used as robot memory, TTRL used for vision-language models, context-internalization objectives used to train fast weights).

Scope. We use test-time training in the narrow sense: a method belongs here when the model learns at inference by optimizing an explicit objective on the test input, context, problem or deployment stream, updating weights, adapters or fast weights. This includes self-supervised TTT, TTT layers and test-time memorization architectures, test-time training and test-time reinforcement learning of language and multimodal models, agents and embodied systems that learn from deployment experience, and their theory, analyses and applications. It excludes, except as background, fully test-time adaptation (TTA) methods whose update is entropy minimization, pseudo-labeling, normalization-statistics re-estimation or teacher–student consistency on unlabeled shifted data, such as Tent ; that literature is large and already surveyed . It also excludes test-time scaling without weight updates (sampling, search, best-of-N, prompting) .

Contributions. (i) A taxonomy organized by what is learned at test time and from which signal, which places classic TTT, TTT layers, LLM test-time training, test-time RL, deployment-time learning of agents and robots, and applications in one tree (Chapter 3). (ii) A shared formal setup in which the main methods of every branch are written as changes to one inner-loop objective (Chapter 2), so that, for example, the delta rule, Titans, the ARC recipe and TTRL can be compared term by term. (iii) A chapter on foundational questions that collects evidence on both sides of five live disputes (Chapter 9). (iv) Inventories of benchmarks and recurring evaluation protocols (Chapter 10) and a set of open problems derived from the inspected evidence (Chapter 12).

Roadmap. Figure 1 shows the organization. Chapter 2 fixes definitions, notation and the timeline and compares related surveys. Chapter 3 introduces the taxonomy. Chapters 4–8 cover the six branches. Chapter 9 discusses the foundational questions, Chapter 10 resources, Chapter 11 applications, and Chapter 12 future directions. The appendix records retrieval routes, counts and reading depth.

mermaid
flowchart LR P[Ch 2 Preliminaries: definitions, notation, timeline, related surveys] --> T[Ch 3 Taxonomy: what is learned at test time, from which signal] T --> A[Ch 4 Self-supervised TTT for robustness] T --> B[Ch 5 TTT layers and test-time memorization] T --> C[Ch 6 TTT of language and multimodal models] T --> D[Ch 7 Test-time reinforcement learning] T --> E[Ch 8 Agents, robots and world models] A --> Q[Ch 9 Foundational questions] B --> Q C --> Q D --> Q E --> Q Q --> R[Ch 10 Resources and Ch 11 Applications] R --> F[Ch 12 Future directions]

Figure 1. Organization of the survey. Chapters 4–8 follow the six branches of the taxonomy (applications are gathered in Chapter 11).

2 Preliminaries

2.1 Definitions and boundaries

Test-time training names a procedure, not an architecture: during inference the model optimizes a learning objective whose data come from the test situation and uses the result to predict. Three neighbouring notions share part of this description and are worth separating.

  • Fully test-time adaptation (TTA). TTA also updates a deployed model on unlabeled test data, but its objective is a confidence or consistency surrogate on the main task's outputs: entropy minimization over normalization parameters , pseudo-labeling or teacher–student agreement. Classic TTT differs in that the training procedure deliberately creates a separate learning problem (an auxiliary task, a reconstruction target) that is still well-defined on a single unlabeled input . The boundary is not perfectly sharp; some methods discussed in Chapter 4 combine both .
  • In-context learning and test-time scaling. A transformer conditioning on demonstrations, or a reasoning model sampling and verifying many candidates, also uses test data to improve its answer, but no parameter changes. TTT and these approaches are alternative ways to spend inference compute, and several papers compare them directly .
  • Online and continual learning. Learning from a stream of labeled data after deployment is older than TTT. What distinguishes TTT is that the training signal at test time is constructed without ground-truth labels for the query (self-supervision, the context itself, a self-derived or verifier reward), and that the outer loop usually anticipates the inner loop.

A broader umbrella, test-time intelligence, groups TTA, test-time learning and test-time scaling and organizes them by feedback signal, updated state, temporal horizon and objective . The present survey is deliberately narrower and deeper within it.

2.2 Shared formal setup

A model fθf_\theta is trained, then deployed with parameters θ0\theta_0. At test time it receives data Dtest\mathcal{D}_{\text{test}} (one input, a batch, a context, a test task with demonstrations, or a stream) and runs KK steps of an inner loop

θk+1=θk−η ∇θ ℓtest(θk;Dtest),k=0,…,K−1,\theta_{k+1}=\theta_k-\eta\,\nabla_\theta\,\ell_{\text{test}}(\theta_k;\mathcal{D}_{\text{test}}),\qquad k=0,\dots,K-1,

then predicts with θK\theta_K. The outer loop (pre-training or meta-training) shapes θ0\theta_0 and often the inner objective itself, either by joint training with ℓtest\ell_{\text{test}} or by differentiating through the inner loop. Methods differ in four choices: which parameters the inner loop updates, which loss it minimizes, which data it sees, and whether the update persists (episodic reset vs. online accumulation). The branches of this survey instantiate this template as follows.

Self-supervised TTT. With a shared encoder θe\theta_e, main head θm\theta_m and auxiliary head θs\theta_s, training minimizes ℓm(x,y;θe,θm)+λ ℓs(x;θe,θs)\ell_m(x,y;\theta_e,\theta_m)+\lambda\,\ell_s(x;\theta_e,\theta_s); at test time θe←θe−η∇θeℓs(x;θe,θs)\theta_e\leftarrow\theta_e-\eta\nabla_{\theta_e}\ell_s(x;\theta_e,\theta_s) on the unlabeled xx .

TTT layers. Tokens provide keys, values and queries kt,vt,qtk_t,v_t,q_t. The layer's state is a fast-weight model WtW_t (a matrix or a small MLP fWf_W), trained online on an inner loss such as ℓ(W;kt,vt)=∥fW(kt)−vt∥2\ell(W;k_t,v_t)=\|f_W(k_t)-v_t\|^2:

Wt=αtWt−1−ηt∇Wℓ(Wt−1;kt,vt),ot=fWt(qt),W_t=\alpha_t W_{t-1}-\eta_t\nabla_W\ell(W_{t-1};k_t,v_t),\qquad o_t=f_{W_t}(q_t),

with retention αt\alpha_t and inner learning rate ηt\eta_t. Linear attention is the additive write Wt=Wt−1+vtkt⊤W_t=W_{t-1}+v_tk_t^\top; the delta rule is one SGD step on the squared loss, Wt=Wt−1−ηt(Wt−1kt−vt)kt⊤W_t=W_{t-1}-\eta_t(W_{t-1}k_t-v_t)k_t^\top .

LLM test-time training. A model πθ\pi_\theta receives a test problem, demonstrations or context cc and minimizes Ltest(θ;c)\mathcal{L}_{\text{test}}(\theta;c), usually a next-token loss on cc or on augmentations of it, typically through LoRA adapters Δθ\Delta\theta .

Test-time RL. For a test question xx, sample y1,…,yN∼πθ(⋅∣x)y_1,\dots,y_N\sim\pi_\theta(\cdot|x), set a reward from a self-derived signal, for example r(yi)=1[ans(yi)=a^]r(y_i)=\mathbb{1}[\mathrm{ans}(y_i)=\hat a] with a^\hat a the majority answer, and update θ\theta by a policy-gradient objective .

SymbolMeaning
θ0\theta_0, θk\theta_kdeployed parameters; parameters after kk inner steps
ℓtest\ell_{\text{test}}, η\eta, KKinner (test-time) objective, inner learning rate, number of inner steps
θe,θm,θs\theta_e,\theta_m,\theta_sshared encoder, main head, auxiliary (self-supervised) head
ℓm\ell_m, ℓs\ell_smain-task loss; self-supervised loss
kt,vt,qtk_t,v_t,q_tkey, value, query of token tt
WtW_t, fWf_Wfast-weight state after token tt; inner model parameterized by WW
αt\alpha_t, ηt\eta_tretention (forget) gate and inner learning rate at token tt
bbinner mini-batch (chunk) size
πθ\pi_\theta, cc, Δθ\Delta\thetalanguage model, test context or task, adapter update
yiy_i, a^\hat a, rrsampled response, self-derived pseudo-label, reward

Table 1. Notation used throughout. When a paper uses different symbols, the correspondence is stated where the paper is discussed.

2.3 Development timeline

The lineage has two roots. One is the fast-weight idea: a slow network that programs the weights of a fast one, revived when linear transformers were shown to be outer-product fast-weight programmers and given a delta-rule write . The other is the 2019 TTT paper, which made the test input itself a training example . Masked autoencoding replaced rotation prediction in 2022 , and the 2023 video-stream work turned per-image adaptation into an online learner that never resets . In 2023–2024 the two roots met: the TTT layer made the recurrent state of a language model a learner trained by self-supervised gradient steps , and the same year test-time fine-tuning of LLMs on nearest neighbours and on ARC demonstrations established TTT as a way to spend inference compute . 2025 brought deep neural memories and unifying frameworks , large-chunk TTT for images and video , and test-time RL . By 2026 the ideas had reached long-context LLMs without architectural change , scientific discovery , agents and video world models .

mermaid
timeline title Representative milestones in test-time training 2019 : TTT with rotation self-supervision [1] 2020 : Policy adaptation during deployment [28] 2021 : Linear transformers as fast weight programmers [17] 2022 : TTT with masked autoencoders [19] 2023 : TTT on video streams [20] : TTT on nearest neighbours for LLMs [21] 2024 : TTT layers [2] : Gated DeltaNet [29] : TTT for ARC [5] 2025 : Titans [3] : TTRL [6] : LaCT [23] : TTT-E2E [24] 2026 : TTT-Discover [7] : In-Place TTT [25] : World-T3 [27]

Figure 2. Milestones by first arXiv version. A year marks when the idea appeared, not when it was published at a venue.

Several surveys touch this literature, but each organizes it around a different question. Table 2 compares them.

SurveyScope and cutoffOrganizing axesWhat this survey adds
Comprehensive survey on TTA TTA under distribution shift, 2023form of test data (domain, batch, instance adaptation)narrow-sense TTT including architectures, LLMs and RL, which postdate it
Beyond model adaptation at test time TTA, 2024what is adapted (model, inference, normalization, sample, prompt)same as above
Online TTA survey online TTA with ViT benchmarks, 2023three method categories plus benchmarktreats TTA only as background
Test-time scaling in LLMs inference-compute scaling, 2025what, how, where and how well to scalethe weight-updating part of inference compute (TTT, TTRL) in depth
Memory-augmented Transformers memory mechanisms, 2025functional objective, representation, integrationparametric test-time memory treated as learning with an inner objective
Fast weight programming 2D-state RNNs, ML to neurobiology, 2025fast-weight programmers and their biologyconnects fast weights to classic and LLM TTT
Self-improving test-time intelligence TTA + test-time learning + test-time scaling, 2026feedback signal, update target, temporal horizon, objectiveone shared notation across branches; architecture line in depth; debates chapter

Table 2. Related surveys. Rows are surveys located in the library whose subject overlaps TTT; scope and axes are taken from their abstracts, and for the 2026 survey also from its introduction and the first part of its test-time learning section. Cutoffs are the first arXiv year.

Takeaways

  • Narrow-sense TTT is defined by an explicit inner learning objective on test data; it is distinct from TTA (confidence surrogates), test-time scaling (no weight change) and supervised online learning.
  • One template, an inner loop over test-time data shaped by an outer loop, covers classic TTT, TTT layers, LLM test-time training and test-time RL; methods differ in parameters, loss, data and persistence.
  • Existing surveys either cover TTA, cover test-time scaling, or place TTT under a broad umbrella; none writes the architecture, LLM and RL lines in a common notation.

3 Taxonomy

The primary axis of this survey is what the model learns at test time and from which signal. The axis is chosen because it separates lines of work that otherwise share vocabulary but answer different questions. A self-supervised TTT method and a TTT layer both run gradient steps at inference, but the first adapts a fixed predictor to a shifted input using an auxiliary task, while the second is the sequence model's memory and learns key-value associations of the context on every forward pass. An LLM fine-tuned on ARC demonstrations and an LLM trained with TTRL both update LoRA weights on test data, but the first has supervised demonstrations and the second must invent its own reward. Grouping by signal and learned object keeps each branch's methods comparable on one objective.

Six branches follow:

  1. Self-supervised TTT for robustness (Chapter 4): a predictor adapts its encoder on each test input or stream with an auxiliary self-supervised loss; the target is generalization under distribution shift.
  2. TTT layers and test-time memorization (Chapter 5): the hidden state of a sequence layer is a fast-weight model trained online on key-value associations; the target is memory of the context at constant cost.
  3. Test-time training of language and multimodal models (Chapter 6): a foundation model is fine-tuned at inference on the test task's demonstrations, retrieved neighbours or long context; the target is task specialization or context internalization.
  4. Test-time reinforcement learning (Chapter 7): a reasoning model updates its policy on unlabeled test questions using self-derived rewards.
  5. Agents, robots and world models (Chapter 8): deployed decision-making systems turn verified experience, environment feedback or the observed dynamics into weight updates.
  6. Applications (Chapter 11): domain adaptations of the above in medicine, speech, time series, recommendation, graphs and science.

Two secondary axes cut across branches and appear in tables: the persistence of the update (episodic reset per input, per-episode adapters, or online accumulation over a stream) and the outer-loop coupling (none, joint training with the inner loss, or meta-learning through the inner loop). Figure 3 shows the tree with representative works at the leaves.

mermaid
mindmap root((Test-time training)) Self-supervised TTT Auxiliary-task TTT · 1, 19, 32 Meta-learned and tailored TTT · 33, 34 Online and streaming TTT · 20, 35 TTT layers and memory Fast weights and delta rule · 17, 29, 36 Neural memory and objectives · 2, 3, 37 Unifying frameworks · 18, 22, 38 Training and systems · 23, 39, 40 Vision, video and 3D · 4, 41, 42 LLM test-time training Task-level TTT · 5, 43, 44 Retrieval and active data · 21, 45 Context internalization · 24, 25, 46 Discovery · 7, 47 Test-time RL Consensus rewards · 6, 48 Reward reliability and collapse · 49–51 Curricula and critics · 52, 53 Agents and embodied LLM agents · 26, 54, 55 Robots and driving · 28, 56, 57 World models · 27, 58

Figure 3. Taxonomy of test-time training by what is learned at test time and from which signal. Numbers are references; applications (Chapter 11) are omitted from the tree for space.

The branches are not mutually exclusive. A TTT layer can be the memory of a robot policy ; an LLM can be fine-tuned on its own long context with a next-token objective that is simultaneously a TTT-layer write rule ; a discovery system combines test-time RL with search . Such works are discussed where their mechanism is most informative and cross-referenced elsewhere.

Takeaways

  • The organizing question is what the inner loop learns and from which signal: an auxiliary task, key-value associations, demonstrations or context, self-derived rewards, or deployment experience.
  • Persistence (episodic vs. online) and outer-loop coupling (joint training vs. meta-learning) are secondary axes that recur in every branch.
  • The newest work increasingly crosses branches, which is why one shared notation is useful.

4 Self-Supervised Test-Time Training for Robustness

The founding problem of TTT is distribution shift: a classifier trained on clean images loses accuracy on corrupted, re-rendered or temporally drifted ones, and the shift is unknown in advance. Domain adaptation needs target data before deployment and domain generalization must anticipate the shift. Self-supervised TTT takes a third route: let every test input teach the model something about its own distribution before the model answers.

mermaid
flowchart LR R((Self-supervised TTT)) --> A[Auxiliary objective · 1, 19, 32, 61, 62] R --> B[Training coupling · 14, 33, 34] R --> C[Online and streaming · 20, 35] R --> D[New modalities · 63–65]

Figure 4. Subtree of Chapter 4 with representative works.

4.1 Auxiliary-task TTT

The original method trains a Y-shaped network, a shared encoder θe\theta_e with a main classification head θm\theta_m and a rotation-prediction head θs\theta_s, jointly on both losses. At test time the encoder is updated on the rotation loss of the single unlabeled test image, with the main head frozen, and the prediction is made with the updated encoder; an online variant carries the encoder from one test image to the next instead of resetting it . On CIFAR-10-C at the highest corruption level the method lowers Gaussian-noise error from 50.5% without adaptation to 45.6%, and the online variant to 25.8%, without raising error on the clean test set (8.9% to 7.9%). The same paper offers the explanation that has shaped the field since: for a convex, smooth model and one gradient step, a self-supervised update improves the main loss whenever the gradients of the two losses are positively correlated, and across 75 test sets the measured gradient correlation tracks the realized gain. It also names the limitation that runs through the branch: the auxiliary task must carry information about the main task, and on some classes, where rotation is ambiguous, it does not.

The next step changed the auxiliary task rather than the recipe. TTT-MAE uses masked-autoencoder reconstruction with a ViT encoder, reconstructs 75%-masked test images for 20 steps per image, and resets after each image . Figure 5 shows the mechanism: reconstruction loss on the corrupted input falls only slightly while the classification loss falls much more, which is the gradient-alignment argument made visible. The gains on ImageNet-C are large at severity 5 (for example, glass blur from 18.4% to 36.9% accuracy), and the paper extends the theory to a linear model in which some step size strictly beats not adapting. A third family keeps the Y shape but replaces hand-designed pretext tasks with objectives defined on features: a normalizing flow over source features whose likelihood becomes the test-time loss , an information-maximization clustering head , a noise-contrastive discriminator and contrastive feature reconstruction across encoder layers . On CIFAR-10-C with ResNet-50 these report average accuracies around 82–83% against roughly 54% for the unadapted model, but the improvements over one another are a point or less, and several of them lose to the unadapted model under the mild natural shift of CIFAR-10.1 . Other variants change what is optimized rather than the task: IT³ trains the network to be idempotent and at test time restores idempotence against a frozen copy , and mixing test images with training images during the update reduces the mismatch between adapted and source features .

*Figure 5. Test-time training with masked autoencoders

1919

: a Gaussian-noise-corrupted image is masked and reconstructed; over 0, 50 and 500 steps the reconstruction loss changes from 0.63 to 0.58 while the classification loss falls from 4.81 to 2.36 (reproduced from Figure 1 of the original paper).*

The breadth of the line is wide. The same encoder-update recipe has been used for zero-shot sketch-based retrieval , universal cross-domain retrieval , segmentation with an output contrastive loss , depth-aware video object segmentation , 3D segmentation with knowledge distillation from foundation models , image-manipulation localization , handwritten documents , multi-view stereo and point-cloud registration with meta-auxiliary learning and adversarial-mask discriminators reused as the auxiliary task . Later work has also asked how to align the auxiliary and main tasks more tightly and how to handle open-world streams that contain unknown classes .

4.2 Coupling training to the test-time update

Joint training only hopes that the auxiliary gradient will help the main task. Meta-learning makes that the training objective. MT3 wraps TTT in MAML: the inner loop takes one BYOL-style self-supervised step on a single unlabeled image and the outer loop minimizes the classification loss after that step . On CIFAR-10-C the average accuracy over 15 corruptions is 75.6% against 69.0% for the original TTT and 73.5% for joint training with the same BYOL loss, and adaptation itself contributes 4.2 points. Tailoring generalizes the idea: any unsupervised objective can be minimized at the query point, and meta-tailoring trains the network so that this inner minimization helps the supervised loss, with gains reported on physical-dynamics prediction and certified robustness . Meta-TTT applies meta-learning to normalization parameters and a minimax entropy objective, so it sits on the boundary with TTA . Meta-auxiliary learning, which trains an auxiliary task so that its gradient is useful at test time, has spread to pose prediction, documents, point clouds and stereo .

4.3 Online and streaming TTT

Episodic TTT resets after every input and so cannot exploit the fact that consecutive test inputs usually share a distribution. TTT on video streams makes the update online: the encoder is never reset (implicit memory) and each step trains on the current frame together with a short sliding window of previous frames (explicit memory), one gradient step per frame, with all heads jointly trained . On a new egocentric COCO Videos benchmark it more than doubles instance-segmentation AP over the fixed model (37.6 against 16.7) and even beats an offline oracle that trains on all frames of the video, while a small theorem explains why a short window is optimal under temporal smoothness. The same online choice transferred to 3D point clouds, where MATE adapts with masked point reconstruction and reaches 71.3% mean accuracy on ModelNet-40C against 53.9% for the source model . The realistic streaming protocol was formalized by TTAC++, which distinguishes sequential from multi-pass and source-free from source-statistics settings and shows that on the natural CIFAR-10.1 shift sequential TTT gains almost nothing . Later streaming work studies domain-incremental video streams, long videos and continual masked-autoencoder adaptation .

4.4 New modalities and inverse problems

When the recipe moves to a new modality the auxiliary task must be redesigned. For graphs, rotation is meaningless; GT3 uses a node–graph and node–node contrastive task defined within a single test graph and adds a regularizer that pins the test graph's embedding statistics to training statistics to prevent per-sample overfitting . For speech, a mel-spectrogram MAE provides the task, and updating only the encoder's bias terms is more stable across steps than full fine-tuning; under traffic noise, speaker-identification accuracy rises from 28.4% to 57.2% . For accelerated MRI the auxiliary task is replaced by measurement consistency: the network is trained with a data-consistency term and at test time is fitted to that term on each measurement with early stopping, closing between 87% and 99% of the SSIM gap caused by anatomy, dataset, modality or acceleration shifts at a cost of minutes per slice . Related inverse-problem work uses equivariance or plug-and-play priors as the test-time signal .

4.5 Where the evidence stands

The inspected studies agree on three points. First, TTT helps most under severe synthetic corruptions and much less under natural shifts such as CIFAR-10.1, where several methods do not beat the unadapted model . Second, whether the auxiliary gradient aligns with the main task is the controlling variable; it is predicted by theory in convex or linear settings and measured empirically, but there is no general recipe for choosing a task, and modality-specific redesign is the norm . Third, online accumulation can be much stronger than episodic reset when the stream is temporally smooth, and harmful when it is not: shuffling video frames makes TTT worse than no adaptation . Comparisons across papers are limited by differing backbones, batch sizes and protocols; the gains reported for feature-space auxiliary tasks are within a point of one another on CIFAR-10-C.

MethodAuxiliary objectiveUpdated parametersProtocolCoupling
TTT rotation predictionshared encoderepisodic; online variantjoint training
TTT-MAE masked image reconstructionencoder and decoderepisodic, 20 stepsfrozen MAE + probed head
MT3 BYOL invarianceall but classifierepisodic, 1 stepmeta-learned
TTTFlow normalizing-flow likelihood of featuresearly encoder layersper batchseparate training
Video-stream TTT masked reconstruction over a frame windowencoder and decoderonline, never resetjoint training
MATE masked point reconstructionencoder, decoderepisodic or onlinejoint training
GT3 hierarchical graph contrastive + statistics anchorshared GNN layersepisodic per graphjoint training
Speech TTT mel-spectrogram MAEencoder (bias-only variant)episodiclinear probe
CS-MRI TTT measurement consistencywhole networkper measurement, early stoppedjoint training

Table 3. Representative self-supervised TTT methods compared on the components of the shared setup. Entries follow each paper's main configuration; results are not comparable across rows because data, backbones and protocols differ.

Takeaways

  • Self-supervised TTT works when the auxiliary gradient is aligned with the main task; this is proved in simple models, measured empirically, and is why task design dominates the line.
  • Gains are large under severe synthetic corruptions, small or absent under mild natural shifts, and differences between recent auxiliary objectives on CIFAR-10-C are about a point.
  • Online TTT over smooth streams can beat even offline oracles, but depends on temporal coherence.

5 TTT Layers and Test-Time Memorization

Softmax attention keeps every key and value of the context and pays a cost that grows with its length. Recurrent models compress the context into a fixed-size state, but a vector state or a matrix updated by a hand-designed rule loses information quickly. The TTT-layer line asks what happens if the state is itself a model and the update rule is learning: each token is a training example for a small inner model, and the forward pass of the sequence model trains it. The idea unifies a long history of fast weights with modern linear recurrences and has produced the most active branch of the field.

mermaid
flowchart LR R((TTT layers)) --> A[Write rules: additive, delta, gated delta · 17, 29, 36, 88] R --> B[Deep memory and richer objectives · 2, 3, 37, 89] R --> C[Exact and second-order solvers · 90, 91] R --> D[Unifying frameworks · 18, 22, 38] R --> E[Training and systems · 23, 39, 40, 92] R --> F[Vision, video and 3D · 4, 41, 42, 93]

Figure 6. Subtree of Chapter 5 with representative works.

5.1 From fast weights to the delta rule

Linear attention without softmax normalization can be written as a fast-weight programmer: the state WtW_t is a matrix, each token writes the outer product vtkt⊤v_t k_t^\top, and the output reads WtqtW_t q_t . Written this way, the additive write has an obvious defect: it can only add, so once more associations are written than the key dimension supports, retrieval degrades, and the paper measures that degradation on synthetic retrieval. Its remedy is the delta rule, which first reads the value currently stored under ktk_t and writes only the correction, Wt=Wt−1+βt(vt−Wt−1kt)kt⊤W_t=W_{t-1}+\beta_t(v_t-W_{t-1}k_t)k_t^\top, with a learned write strength βt\beta_t. In the shared notation this is one SGD step with inner learning rate ηt=βt\eta_t=\beta_t on the squared loss 12∥Wkt−vt∥2\tfrac12\|Wk_t-v_t\|^2. On WikiText-103 the delta rule improves perplexity over the additive linear transformer (31.5 vs 33.0) but stays behind softmax attention (29.6). Earlier and parallel work in the same tradition trained fast-weight memories for associative inference and meta-learned fast-weight language models .

Two obstacles kept the delta rule from scale. Training it was sequential, and it had no explicit way to forget. The first was removed by a chunkwise-parallel algorithm built on the WY representation of products of Householder matrices, which trained DeltaNet at 1.3B parameters on 100B tokens to perplexity comparable to Mamba and a Transformer baseline . The second was removed by Gated DeltaNet, which multiplies the state by a data-dependent decay before the delta step, Wt=αtWt−1(I−βtktkt⊤)+βtvtkt⊤W_t=\alpha_t W_{t-1}(I-\beta_t k_tk_t^\top)+\beta_t v_tk_t^\top, so gating erases in bulk while the delta rule writes selectively . At 1.3B parameters it reports the best average among recurrent baselines on language modeling and LongBench, but the same table shows that on real-world retrieval it still trails a Transformer and hybrid models. Longhorn derives a related rule as the closed-form solution of an online least-squares problem, so that the forget gate is a function of the key instead of a separate parameter . Later variants change the transition structure or the preconditioning: products of several Householder steps , decoupled erase and write , closed-loop control , curvature-aware preconditioning and Kaczmarz-style projections .

5.2 Expressive hidden states: TTT layers and neural memory

The TTT layer generalizes the delta rule in two directions at once . The inner model fWf_W may be a linear map (TTT-Linear) or a two-layer MLP (TTT-MLP); the inner loss is a reconstruction of a learned view θVxt\theta_V x_t from another learned view θKxt\theta_K x_t, so the outer loop decides what self-supervised task the state solves; and the inner optimizer uses mini-batch gradient descent over chunks of b=16b=16 tokens, which makes training parallel within a chunk. The paper's ablation starts from an exact linear-attention equivalent and adds one design element at a time: perplexity at 125M parameters and 2K context falls from 15.23 to 11.09, with mini-batch TTT and a normalization-plus-residual inside ff contributing the most. At 8K and 32K context both variants beat Mamba, and the gap grows with context. The cost is wall-clock: TTT-MLP is FLOP-efficient but memory-bound, and the authors call their systems work preliminary.

Titans turned this into a deep neural memory with a richer update . The memory is an MLP trained on the associative loss ∥M(kt)−vt∥2\|\mathcal{M}(k_t)-v_t\|^2 with momentum, which the paper calls surprise, and an adaptive weight decay that acts as a forget gate: Mt=(1−αt)Mt−1+St\mathcal{M}_t=(1-\alpha_t)\mathcal{M}_{t-1}+S_t, St=ηtSt−1−θt∇ℓS_t=\eta_t S_{t-1}-\theta_t\nabla\ell. Figure 7 shows the memory-as-context variant, which retrieves from the neural memory, prepends persistent learned tokens and lets windowed attention combine them with the current segment before the memory is updated. At 760M parameters Titans reports lower WikiText perplexity than a Transformer and Gated DeltaNet hybrids, and on single needle-in-a-haystack tasks it holds above 95% at 16K where TTT and DeltaNet collapse. A reimplementation study later confirmed that the neural memory, rather than chunking or persistent tokens, is what carries the gains, but also that the model did not beat a strong recommendation baseline at small scale .

*Figure 7. The memory-as-context design of Titans

33

: a contextual neural memory is queried with the current segment, persistent data-independent weights are prepended, attention runs over the result, and the neural memory is updated at test time (reproduced from Figure 2 of the original paper).*

Successors changed what the inner loss sees and how it is optimized. ATLAS evaluates the inner objective over a window of past tokens rather than the current one (the "Omega rule"), lifts capacity with polynomial feature maps and uses a Newton–Schulz (Muon) inner optimizer; its ablation shows that returning to a single-token objective costs the most perplexity, and it keeps above 80% accuracy on BABILong at 10M tokens . Lattice normalizes the columns of the state onto the sphere so that each memory slot is written only with the component of the input orthogonal to it ; Trellis applies a gradient write with a forget gate to a compressed key-value memory . Nested Learning recasts architecture and optimizer as nested associative memories updated at different frequencies and adds self-modifying memories and a continuum of MLP blocks updated at geometrically spaced rates . The breadth of this sub-line includes memories trained with different targets or readouts , memories shared across layers and composable TTT modules .

5.3 Exact and second-order inner solvers

A single gradient step is a crude solver. MesaNet replaces it with the exact minimizer of a forget-weighted, ridge-regularized least-squares objective over all past key-value pairs, computed with conjugate gradients whose expensive part is itself a gated linear attention, so training stays chunkwise parallel . At about 1B parameters it matches a Transformer and Gated DeltaNet in perplexity and extrapolates to 32K context where DeltaNet and the Transformer degrade badly. Gated KalmaNet takes the same direction with a Kalman-gain (recursive least squares) update stabilized by an input-dependent ridge, and reports gains over Gated DeltaNet at 2.8B parameters on zero-shot tasks while noting that it falls behind on synthetic recall beyond 4K . The same exact-ridge write is the memory of the World-T3 video model discussed below.

5.4 Unifying frameworks

Two papers recast this design space as regression. Test-time regression treats the memorization step of associative recall as a regression problem solved inside the forward pass and derives layers from three choices: how past associations are weighted, which regressor class is used, and which optimizer solves it . In this view linear attention is one unpreconditioned gradient step, the delta rule is one SGD step per token, recursive least squares is the exact solution, and softmax attention is a local-constant (Nadaraya–Watson) regressor; the paper also shows an exact one-to-one reparameterization between L2-regularized streaming SGD and the Gated DeltaNet recurrence. Miras (It's All Connected) builds a four-slot template — memory architecture, attentional bias (the inner objective), retention gate and memory algorithm — and shows that it covers Transformers, linear attention, Mamba, DeltaNet, Longhorn, TTT layers and Titans as special cases . Figure 8 reproduces the template. Changing the attentional bias from squared error to other losses yields new models; at 1.3B parameters one of them reaches lower perplexity than Gated DeltaNet and a Transformer, and another averages 93.5% on single needle-in-a-haystack against 75.8% for Gated DeltaNet.

*Figure 8. The Miras design template

2222

: an associative memory is defined by its architecture, its internal objective (attentional bias), its retention gate and the algorithm that learns the mapping (reproduced from Figure 1 of the original paper).*

5.5 Training efficiency and systems

The practical obstacle of nonlinear TTT layers is hardware utilization: per-token or small-chunk updates of an MLP state are memory-bound. LaCT inverts the default: it takes one nonlinear inner step per very large chunk, from 2K to 1M tokens, uses a SwiGLU fast weight that can hold a large fraction of the model's parameters, a dot-product inner loss and a Muon update, and leaves local structure within a chunk to window attention . The change raises GPU utilization by orders of magnitude and lets a chunk be a set of images or a group of video frames. On novel-view synthesis it approaches full attention in quality (37.6 vs 37.9 PSNR at 48 views) with prefill 1.4 s against 16.1 s; on language modeling it beats GLA and DeltaNet with sliding windows on RULER but remains far behind full attention.

Other work recovers what large chunks lose. TNT decouples chunk size from quality with a hierarchical memory, a global memory at large chunks and local memories at small chunks that are periodically reset, and reaches a target loss 17.37 times faster than the most accurate Titans configuration . ParaTTT makes the exact token-by-token recurrence the fixed point of an iterated chunkwise-parallel computation and reports a 4.9 times training speedup at 340M parameters ; E²-TTT gives a closed-form chunk-end transition that exactly reproduces token-wise momentum and decay and improves length extrapolation on RULER . Systems work continues with batched serving of per-request TTT state , token-parallel training through costate prediction , layerwise optimization of nonlinear memories and retrofitting pre-trained LLMs with neural memory modules , which converts four attention layers of a 1B model, post-trains only about 1% of the parameters, and keeps pass-key retrieval perfect to 32K.

5.6 Vision, video and 3D

Large-chunk TTT made the idea practical for images and video. ViT³ ablates the inner loop systematically for vision — loss, inner batch, epochs, learning rate, inner-model family — and distills six design rules; one full-batch gradient step on a dot-product loss over all tokens of an image works best, and the resulting model reaches 81.6% ImageNet top-1 against 79.8% for DeiT-S at similar FLOPs, with large speed and memory advantages at high resolution . TTT layers have since served as backbones for medical segmentation, facial action units, hyperspectral classification and remote-sensing change detection , and for linearizing pre-trained vision transformers .

For video, One-Minute Video Generation inserts TTT-MLP layers after local attention in a pre-trained diffusion transformer, gates them and runs them over the whole sequence, extending a 3-second generator to 63-second videos (Figure 9) . In human pairwise evaluation at 63 seconds it receives the highest Elo among the compared designs (1033 against 999 for the runner-up, sliding-window attention), but at 18 seconds Gated DeltaNet wins, and the layer is slower than both linear baselines. In 3D, TTT3R reinterprets the state update of the streaming reconstructor CUT3R as a TTT step with learning rate fixed at one and replaces it with a closed-form, per-token learning rate computed from attention alignment; without retraining, the authors report roughly halving pose error on 1,000-view ScanNet sequences at unchanged cost . tttLRM treats LaCT fast weights as an implicit 3D latent that virtual-view queries decode into explicit Gaussians , and World-T3 uses a fixed-size ridge-regression memory keyed by camera pose as the persistent memory of a real-time video world model, improving revisit consistency over a strong baseline . Further 3D and video systems include large-scale and streaming reconstruction , spatial memory and long-video understanding .

*Figure 9. TTT layers in a video diffusion transformer

44

: each block adds a gated TTT layer after local attention (left), and the TTT layer runs across all 3-second segments of a one-minute video while attention stays local (right) (reproduced from Figure 3 of the original paper).*

5.7 Where the evidence stands

LayerStateInner objectiveUpdateRetentionReported strengthReported weakness
Linear attention matrixnone (additive write)Wt−1+vtkt⊤W_{t-1}+v_tk_t^\topnoneparallel, simplecapacity saturates
DeltaNet matrixsquared error1 SGD stepnoneperplexity near Transformer at 1.3Bweak length generalization
Gated DeltaNet matrixsquared errorgated SGD stepscalar gatebest recurrent average at 1.3Btrails attention on real retrieval
TTT-Linear / MLP matrix / MLPlearned-view reconstructionmini-batch GD, b=16b=16nonekeeps improving to 32Kwall-clock cost
Titans deep MLPsquared errorGD with momentumweight decayneedle retrieval to 16Kslower than linear layers
ATLAS MLPwindowed (Omega) squared errorMuongateBABILong at 10M tokensTransformers still lead in-context recall
MesaNet ridge solutioncumulative ridge lossexact (CG)gate32K extrapolationextra inference FLOPs
LaCT SwiGLUnegative dot product1 Muon step per large chunkL2 normalizationhardware utilization, NVS qualityfar behind attention on RULER
TTT-E2E last-quarter MLPsnext-token lossmini-batch GD, 1K tokensnoneflat loss gap to 128Knear-zero needle recall at 128K

Table 4. TTT layers written in the shared notation. Strengths and weaknesses are the authors' or replicating studies' reported results under each paper's own settings; rows are not a ranking.

The inspected evidence supports a consistent picture. Every step from additive writes to the delta rule, gating, deeper memories and better inner optimizers has improved language-modeling perplexity and synthetic recall at the 0.3–3B scale, often matching or beating Transformers on perplexity . On precise retrieval from long, realistic contexts the bounded state remains the limit: attention or hybrids still lead on real-world recall and long-context needle tasks in the same papers that report perplexity wins . Whether the nonlinear inner learning itself matters, or whether these layers are better described as linear attention with learned feature maps, is an open dispute taken up in Section 9.1.

Takeaways

  • TTT layers turn a sequence model's state into an online learner; additive linear attention, the delta rule, gated delta rules, deep neural memories and exact ridge solvers are successive choices of inner objective, optimizer and retention.
  • Regression and associative-memory frameworks make these choices explicit and have been used to derive new layers with better perplexity and synthetic recall.
  • Large-chunk updates made nonlinear TTT layers efficient enough for images, video and 3D; precise long-context retrieval remains weaker than attention.

6 Test-Time Training of Language and Multimodal Models

For large pre-trained models the motivation shifts. Distribution shift still matters, but the more common reason to train at test time is that a single prompt is a poor channel for task-specific information: a handful of demonstrations of a novel rule, a document longer than the useful context, or a problem whose solution requires many attempts. TTT spends inference compute on gradient steps instead of, or in addition to, more tokens. This chapter covers four lines: task-level TTT on demonstrations, TTT on retrieved data, internalizing long context into weights, and discovery problems where the model trains on its own attempts.

mermaid
flowchart LR R((LLM test-time training)) --> A[Task-level TTT on demonstrations · 5, 43, 44, 130] R --> B[Retrieved and selected data · 21, 45] R --> C[Context internalization · 15, 24, 25, 46, 131] R --> D[Discovery on one problem · 7, 47]

Figure 10. Subtree of Chapter 6 with representative works.

6.1 Task-level TTT on demonstrations

The Abstraction and Reasoning Corpus is a natural test bed: each task gives two to four input–output grid pairs governed by a novel rule. The ARC TTT recipe converts those demonstrations into a small training set and fine-tunes a LoRA adapter on it per test task before predicting (Figure 11) . The training set is built from leave-one-out in-context episodes — each demonstration in turn becomes the query while the others form the context — expanded by invertible grid transformations; the loss covers all demonstration outputs, and adapters are task-specific rather than shared. On the public ARC validation set, an 8B model already fine-tuned on synthetic ARC data rises from 18.3% to 47.1% pass@2 with TTT, and an ensemble with program synthesis reaches 62.8%, near the reported average human score of 60.2%. On BIG-Bench Hard, without any ARC-specific pre-training, TTT adds 7.3 points over in-context learning. The authors caution that hyperparameters were tuned on the same subset used for ablations.

*Figure 11. Design choices of test-time training for few-shot tasks

55

: demonstrations are turned into leave-one-out and direct input–output examples with augmentations, the loss can cover the test output, all outputs or inputs and outputs, and adapters can be task-specific or shared; the selected options are outlined (reproduced from Figure 2 of the original paper).*

The recipe does not depend on language. A vanilla vision transformer that treats ARC grids as images and fine-tunes on each task's demonstrations reaches 54.5% pass@2 on ARC-1 with an 18M-parameter model and 60.4% with an ensemble, trained from scratch on ARC data alone . A controlled study of two from-scratch ARC models under a common protocol shows that raising the TTT presentation budget improves pass@2 in all twenty matched comparisons, while more pretraining is not uniformly better . ARC competition reports, analyses and later solvers make test-time fine-tuning a standard component , and program-search alternatives optimize latent programs by gradient descent at test time .

Outside ARC, the update can be made much smaller. SLOT optimizes a single additive vector on the final hidden state to minimize the prompt's own next-token loss for three steps and then generates; it reports gains on math and science benchmarks across 13 open models with modest overhead, though without repeated runs and on benchmarks where one item is worth several points . TLM adapts LoRA weights by minimizing the input perplexity of unlabeled test prompts, weighted toward high-perplexity inputs, and reports large relative gains on domain-specific generation but mixed results on reasoning, where it sometimes trails entropy-based TTA . Related work tunes models at test time on synthesized data, reflections or self-curricula and applies the idea to multimodal models .

6.2 Training on retrieved and selected data

When the test input alone is too little data, a model can train on what is near it. TTT on nearest neighbours embeds a test sequence, retrieves its 50 nearest training sequences from a large index, takes one gradient step on each in increasing distance order with the ordinary language-modeling loss, predicts, and resets . Across the 22 Pile tasks this lowers bits per byte by about 20% on average and narrows the gap between GPT-2 and a ten-times-larger model; on most tasks it also beats placing the neighbours in context, a kNN-LM variant and dynamic evaluation. A reproducibility report revisited the method . SIFT replaces top-kk retrieval with greedy selection that minimizes the posterior variance of a linear surrogate at the prompt, which trades relevance against redundancy; it fixes the failure in which near-duplicate neighbours make nearest-neighbour TTT stall and reports lower bits per byte than nearest neighbours under the same budget . A theoretical account of why such local training helps even on in-distribution data is discussed in Section 9.4 .

6.3 Internalizing context into weights

The oldest version of this idea is dynamic evaluation: keep updating a language model on the text it has just read. A systematic revisit treats online adaptation as memory in weights, shows that on a stream of 100 books it lowers cumulative loss below the static model, and that under large distribution shift a small-context model with online adaptation dominates a large-context static model on the compute–loss Pareto front, an ordering that reverses once the model is fine-tuned in-distribution .

Recent work makes this a deliberate long-context mechanism. TTT-E2E keeps a sliding-window Transformer and treats the MLPs of its last quarter of blocks as fast weights: at test time they are trained on the model's own next-token loss over the context in 1K-token mini-batches, and during training the initialization is meta-learned by differentiating through that inner loop . At 3B parameters its loss gap to full attention stays roughly flat from 8K to 128K context, whereas Mamba 2, Gated DeltaNet and sliding-window attention fall further behind, and prefill at 128K is 2.7 times faster; but needle-in-a-haystack recall at 128K collapses to 0.06 against 0.99 for full attention, because compression discards details. In-Place TTT keeps a standard Transformer and turns the down-projection of each gated MLP into fast weights updated once per chunk toward a next-token-aligned target, so pre-trained LLMs can be converted by continual training; on Qwen3-4B it improves RULER at 64K and 128K by a few points . Follow-ups change only the write target, to the next position's hidden state or to a long-window teacher's hidden states , or make the update query-conditioned .

Other lines train adapters on the context directly. PERK meta-learns a LoRA initialization so that a few inner steps on chunks of the context let the model answer questions without the context present; trained at 8K, it retains substantial accuracy at 128K where an in-context fine-tuned baseline scores zero . qTTT does a single prefill, caches keys and values, and then updates only the query projections on spans of the context for a few dozen steps, so the cache stays valid; on LongBench-v2 and ZeroScrolls it improves Qwen3-4B by about 13–14 points over in-context decoding, and it argues analytically that attention scores dilute with context length in a way query updates can repair . Latent Compaction trains a compact key-value cache per document by distilling a full-cache teacher, then reuses it across questions . The same idea appears in prompt memorization, contextual streams, self-consolidation of knowledge and personalization .

6.4 Discovery: training on one hard problem

Search systems for open problems usually keep the language model frozen and evolve a population of candidate programs. TTT-Discover updates the policy online on its own attempts at the single target problem . Its objective favours one excellent solution over good average reward — an entropic utility with an adaptive temperature — and a tree-search rule reuses archived states by their best child. With a 120B open model and a LoRA adapter, it reports new best bounds on an Erdős minimum-overlap problem and an autocorrelation inequality and GPU kernels faster than the best human submissions, at roughly 500 dollars of compute per problem; at a matched budget of 25,600 rollouts, removing the test-time training from the search makes the best kernel substantially slower. ThetaEvolve adds an optional RL phase inside an AlphaEvolve-style loop with a small open model and reports new best-known circle-packing and autocorrelation bounds from an 8B model; RL beats pure inference at matched steps across its tasks . Later systems apply test-time learning to harness optimization, open-ended discovery, small models trained in thought space and hardware design .

6.5 Where the evidence stands

MethodTraining data at test timeParametersSteps / costMain evaluation
ARC TTT augmented leave-one-out demonstrationstask-specific LoRAper taskARC, BBH
VARC augmented demonstrationsfull ViT100 epochs, about 70 s per taskARC-1, ARC-2
TTT-NN 50 retrieved neighboursfull model1 step per neighbourPile bits per byte
SIFT variance-selected datafull or LoRA50 stepsPile bits per byte
SLOT the promptone hidden-state vector3–5 stepsmath, code, QA
qTTT spans of the contextquery projections32 steps after one prefillLongBench-v2, ZeroScrolls
TTT-E2E the contextlast-quarter MLPs, meta-learned initonline, 1K-token batchesloss to 128K, RULER
In-Place TTT the contextMLP down-projectionsone write per chunkRULER to 256K
TTT-Discover own attempts with verifier rewardLoRA50 steps × 512 rolloutsmath bounds, kernels

Table 5. LLM test-time training methods by what they train on and what they update. Costs are as reported and not normalized; evaluations differ across rows.

Across the inspected work, TTT reliably helps when the test task carries information that the prompt channel transmits poorly: novel few-shot rules, prompt-specific distributions, and contexts longer than the model can attend to well . Two costs recur. Compute per query rises by large factors, and the inner loop is a lossy compressor, so tasks that need exact retrieval of a detail from the context suffer . Many headline gains come from single runs on small benchmarks, so the more robust evidence is the consistency of direction across models and tasks rather than individual numbers.

Takeaways

  • Fine-tuning on a test task's own demonstrations, augmented and organized as leave-one-out episodes, brought ARC performance near the reported human average and is now a standard component of ARC solvers.
  • Training on retrieved or actively selected data, or on the context itself, turns inference compute into parametric memory; it improves long-context understanding but can lose exact recall.
  • On hard single problems, updating the policy on its own attempts beats frozen-model search at matched rollout budgets in the inspected studies.

7 Test-Time Reinforcement Learning

Reinforcement learning with verifiable rewards needs labeled answers. Test-time reinforcement learning asks whether a reasoning model can improve on unlabeled test questions by inventing its own reward. The appeal is obvious — deploy on a new problem set, adapt without labels — and so is the risk: a reward derived from the model's own outputs can only reinforce what the model already believes.

mermaid
flowchart LR R((Test-time RL)) --> A[Consensus rewards · 6, 48] R --> B[Better pseudo-labels and rollouts · 51, 165] R --> C[Collapse and its limits · 49, 50, 166, 167] R --> D[External anchors · 52, 53]

Figure 12. Subtree of Chapter 7 with representative works.

7.1 Consensus as reward

TTRL samples many answers to each unlabeled test question, takes the majority answer as a pseudo-label, rewards samples that agree with it and runs GRPO on the test set itself for several passes . On AIME 2024, Qwen2.5-Math-7B rises from 12.9% to 40.2% pass@1, and the average over four benchmarks from 31.1% to 54.9%; greedy accuracy after TTRL matches a model trained with RL on 8.9K labeled problems. The paper explains why majority voting can be a useful label even when wrong: a reward computed against an incorrect majority still marks many incorrect samples as incorrect, so the reward accuracy is higher than the label accuracy (on AIME 2024 the authors measure 37% label accuracy but 92% reward accuracy for the 7B math model). It also shows the ceiling: gains shrink as problems get harder relative to the base model, and training is sensitive to temperature and the number of passes. The same recipe transferred quickly to vision-language models, where a soft frequency reward with an entropy term, applied to just 20 unlabeled images per benchmark, raises InternVL3-2B's mean recognition accuracy from 62.0% to 95.0% . That gain is so large that it is better read as adaptation to the label space and format of each benchmark than as new capability, which the authors acknowledge they cannot yet distinguish. TTRL variants now cover audio question answering, speech recognition, GUI grounding, video anomaly understanding, code, operations research and on-device models .

7.2 Better labels and better rollouts

Most follow-ups keep the transductive protocol and change either the pseudo-label or the sampling. SCOPE weights each vote by the average per-step confidence of the reasoning chain and forms pseudo-labels per subgroup of samples rather than one global majority, raising Qwen3-8B's four-benchmark average from 58.21 (TTRL) to 62.20 . ETTRL replaces independent rollouts with a tree that forks only at high-entropy tokens and rescales advantages by response entropy, reaching better AIME accuracy at 60% of the token budget . Other variants use entropy bands, distribution-aware reward estimation, tool verification, hints, equilibrium consensus, complementary learning when the consensus is wrong, data selection, and multiple-solution rewards .

7.3 Collapse

The most important results in this branch are negative. A theoretical and empirical study of unsupervised RL with verifiable rewards shows that every intrinsic reward of this family is a cross-entropy-shaping reward that sharpens the model's initial distribution: under a KL-regularized one-step optimum the probability of the majority answer grows geometrically until the policy becomes deterministic on it . Empirically, intrinsic rewards match or beat ground-truth rewards early and then collapse, even in the best-tuned configuration, after about a thousand steps; success is decided by how well the model's initial confidence aligns with correctness, not by engineering. A dynamical analysis of a single problem's answer distribution identifies three regimes for exploration bonuses — below a threshold only collapsed equilibria are stable, above another only broad ones, in between the starting point decides — and derives the threshold in closed form; in free-form TTRL a bonus that prevents collapse also lowers pass@1 . Detection-based mitigations monitor the window in which the correct answer is about to vanish from the samples , and a study of spurious signals shows that medium-frequency answers inject most of the noise and that fixed, balanced advantages reduce its amplification .

7.4 Anchoring the reward outside the test set

A second response is to bring in signal the model does not produce itself. Test-time curricula select, for each target benchmark or question, related problems with verifiable answers from a large corpus and run GRPO on those; the majority answer never enters the reward . Qwen3-8B improves from 21.7% to 50.8% on AIME24 and from 13.7% to 29.3% on CodeElo, above a uniform RL post-training baseline of the same size, and the gains are complementary to TTRL. TEMPO periodically retrains a critic on a labeled set so that the reward used for unlabeled test questions does not drift with the policy, and reports large AIME gains over a PPO baseline while keeping pass@8 . Self-play, curriculum synthesis and question generation pursue the same goal without external labels .

7.5 Where the evidence stands

MethodReward sourceRollout / advantage changeProtocolReported failure mode
TTRL majority voteGRPOtransductive, multi-passsensitive to temperature, episodes; bounded by prior
TTRV soft frequency + entropyGRPO20 images per benchmarkoccasional regressions
SCOPE confidence-weighted subgroup votesGRPOtransductiveheuristic step segmentation
ETTRL majority voteentropy fork tree, advantage rescalingtransductivehigh temperature collapses training
Spurious-signal mitigation majority votebalanced set, fixed ±1 advantagetransductivesmaller gains on weaker bases
Test-time curricula verifiers on related tasksGRPO, no KLtarget-conditionedneeds a large verifiable corpus
TEMPO critic retrained on labeled setPPOalternating EMneeds labeled data at test time

Table 6. Test-time RL methods by reward source. "Transductive" means adaptation runs on the benchmark's own test questions; results across rows use different models and benchmarks.

Taken together, the inspected studies support three conclusions. Self-derived rewards can produce large early gains when the model's majority is usually right, and those gains are real in the sense that they generalize within a benchmark . They cannot exceed what the model already knows, and with enough steps they collapse onto the initial majority . Most reported results are transductive — trained and evaluated on the same questions — and some benchmark-specific gains may reflect familiarity with the task format rather than reasoning ; anchoring the reward in verifiers on related problems is the most direct way to escape both limits .

Takeaways

  • Majority-vote rewards let reasoning models improve on unlabeled test questions, sometimes matching supervised RL, because reward accuracy exceeds pseudo-label accuracy.
  • The same rewards sharpen the initial distribution and provably collapse onto the initial majority; exploration bonuses trade collapse for accuracy.
  • Rewards anchored outside the test set (verifiers on related tasks, periodically re-fit critics) are the most robust route; transductive evaluation needs care.

8 Agents, Robots and World Models

Decision-making systems meet a version of the test-time problem that is harder in one way and easier in another. It is harder because each mistake changes what the agent sees next, so a bad update compounds. It is easier because the environment often supplies a signal — a verifier, task progress, the next observation — that a classifier on a single image does not have. This chapter covers LLM agents that learn from deployment experience, robot and driving policies that train during or just before deployment, and world models that adapt their dynamics online.

mermaid
flowchart LR R((Agents and embodied TTT)) --> A[Self-edits and synthetic data · 54, 187] R --> B[Experience to weights · 26, 55, 188] R --> C[Robot policies and driving · 28, 56, 57, 189] R --> D[Memory and world models · 27, 58, 59]

Figure 13. Subtree of Chapter 8 with representative works.

8.1 LLM agents learning from experience

SEAL makes the content of a weight update something the model learns to produce . Given a context, the model writes a self-edit — restated facts, implications, or for ARC a choice of augmentations and hyperparameters — which is applied by supervised fine-tuning; the reward is the updated model's downstream performance, and the outer loop reinforces self-edits that helped. On single-passage knowledge incorporation without the passage in context, SEAL reaches 47.0% against 33.5% for training on the passage alone and 46.3% for synthetic data written by GPT-4.1; on a small ARC subset it succeeds on 72.5% of attempts against 20% without the RL loop. The costs are explicit: each reward evaluation is a fine-tuning run of 30–45 seconds, and sequential self-edits cause catastrophic forgetting. For tool-calling agents, a simpler loop selects uncertain test queries by a confidence margin, synthesizes one similar labeled example, trains a throw-away LoRA adapter on it and resets, improving a 1.5B model by 5.5 points on average across four benchmarks .

Long-horizon agents can train on their own trajectories. ASCENT updates a persistent LoRA adapter only after a verifier accepts an episode, and instead of imitating the sampled actions it distils the full next-token distribution of a frozen copy of the initial model that is shown the verified trajectory as hindsight . On ALFWorld a 4B model's success rises from 46.4% to 69.5%, with shorter episodes, and on WebShop from 17.8% to 41.9%. Agentic TTT moves the update inside the episode, every few steps, and down-weights tokens that repeat earlier update texts to avoid a self-reinforcing loop; it adds about five points on ALFWorld and SWE-bench Lite at roughly twice the serving cost . The danger these designs guard against has been measured directly. When a TTT model updates on text it generated itself, the update changes the generator of the next training example; across 128K-token streams, retaining such updates raises the loss on real text, the effect disappears when generation is fixed to the initial weights, and an admission test that accepts an update only if it does not hurt a held-out real passage removes most of the damage . Benchmarks of deployment-time learning evaluate whether agents improve along task streams; one finds that memory-based agents gain far more on multi-turn environments than on single-turn reasoning , and others measure test-time learning ability or memory and continual learning in LLM systems . The breadth includes reflection-driven parametric memory, meta-learned self-improvement policies, test-time environments for web agents and self-improvement with weight updates .

8.2 Robot policies and driving

The first embodied TTT method carried the classic recipe to visual RL: a policy encoder is trained jointly with RL and an inverse-dynamics or rotation self-supervised task, and at deployment only the self-supervised loss keeps updating the encoder, online and without reward . It improves performance in most of its 36 shifted simulation environments and raises real-robot pushing success on a patterned cloth from 64% to 88%, but fails where the auxiliary gradient misaligns with control, as in navigation with inverse dynamics. Vision-language-action models brought environment feedback into the loop. EVOLVE-VLA replaces an oracle success reward with a learned task-progress estimate, accumulated against milestones to reduce noise, and trains the policy with GRPO on its own rollouts while extending the horizon over stages (Figure 14) . In LIBERO simulation it raises average success from 89.2% to 95.8% and, with a single demonstration per task, from 43.6% to 61.3%. TTT-Parkour specializes a generalist humanoid parkour policy to one physical terrain by reconstructing a metric mesh from a short RGB-D capture and fine-tuning in simulation before the run, lifting real success from zero to 60–100% on the tested terrains . In driving, Centaur takes one gradient step on the planner's score decoder to minimize an entropy over coarse direction clusters computed from recent frames, improving the NAVSIM benchmark and a curated safety-critical subset, in open-loop evaluation only .

*Figure 14. Test-time training of a vision-language-action model from environment feedback

5656

: the deployed policy generates rollouts, a progress estimator compares each against the nearest milestone and accumulates progress into a dense reward, GRPO updates the policy, and the exploration horizon grows during training (reproduced from Figure 2 of the original paper).*

TTT layers also serve as robot memory. TTT as residual memory trains fast weights to store only what a bounded explicit memory bank and the current observation fail to explain, improving memory-dependent manipulation benchmarks and three real mobile-manipulation tasks over the explicit-memory baseline . Related work scales robot context with TTT, learns test-time memory for robotics, adapts VLA policies with test-time RL or future-representation objectives, and studies test-time adaptation of trajectory predictors and offline RL agents .

8.3 World models

A world model used for planning fails when the test-time dynamics differ from training. JEPA-TTT turns the deployment stream into training data for the latent dynamics predictor alone: a self-supervised latent-prediction loss, one optimizer step per replanning step, and state carried across episodes, with the encoder and reward head frozen . Across eight hand-built dynamics shifts in four control tasks it more than doubles the frozen model's held-out score and beats a PPO adaptation with oracle reward, though only for one fixed shift at a time. For video world models, World-T3's fixed-size ridge-regression memory keyed by camera pose keeps revisited scenes consistent at 20.6 frames per second . Other work adapts world foundation models for manipulation, trains world models on the test environment, and attaches parameter-efficient residuals to world models at test time .

8.4 Where the evidence stands

Embodied and agentic TTT is younger than the other branches, and most of its evidence is from simulation or small real-world trial counts without uncertainty estimates . The clearest pattern is that the update is gated by a signal external to the model — a verifier, a progress estimate, the next observation, a held-out passage — and that methods without such a gate are unstable over long horizons . Forgetting across many sequential updates is reported but rarely measured .

Takeaways

  • Agents improve by turning verified experience into adapter updates; distillation from a hindsight teacher and admission tests on real data keep the loop stable.
  • Updates driven by self-generated text destabilize long-horizon TTT unless gated by an external signal.
  • Embodied TTT spans self-supervised encoder adaptation, RL from progress estimates, pre-deployment specialization and online world-model learning; evidence is mostly simulation or few real trials.

9 Foundational Questions

Five questions recur across the branches. Each has evidence on more than one side, and in each case part of the disagreement dissolves once the conditions of the experiments are made explicit.

mermaid
flowchart TB Q1[Q1 Are TTT layers more than linear attention] --- E1[Inner loop reduces to learned feature maps · 212, 213] Q1 --- F1[Deep memory and objectives matter · 3, 22, 37] Q2[Q2 Compression versus recall] --- E2[Bounded state loses exact recall · 24, 29] Q3[Q3 Do self-derived signals add knowledge] --- E3[Sharpening and collapse · 49, 188] Q4[Q4 Why TTT helps without shift] --- E4[Specialization and ICL theory · 148, 214] Q5[Q5 What changes for safety] --- E5[Updates as an attack surface · 215–217]

Figure 15. The five foundational questions and the main evidence discussed for each.

9.1 Are TTT layers more than linear attention?

Proposition: the benefit of TTT layers comes from learning a nonlinear model of the context at test time, not merely from a better-parameterized linear recurrence.

Evidence against: a 2026 analysis proves that when the final layer of the inner model is linear and bias-free, unrolling the inner loop gives exactly a linear-attention operator whose query and key feature maps are parameterized by the inner loop, with values given by inner-loss gradients . Reducing LaCT step by step to plain linear attention retains almost all quality on language modeling, novel-view synthesis and ImageNet, and restricting updates to the last layer even improves all three; removing weight normalization makes the layer parallel-scannable and up to four times faster. A dissection of the released TTT-Linear and TTT-MLP models shows that the prediction-dependent part of the inner gradient, the part that makes the update error-correcting, contributes only about 3% to perplexity, whereas freezing all fast-weight updates multiplies perplexity by more than four .

Evidence for: the TTT-layer paper's own ablation shows large perplexity gains from choices that have no linear-attention counterpart, such as mini-batch updates and normalization inside the inner model ; deep memories with momentum and windowed objectives outperform matrix-state baselines on long-context retrieval at the scales tested ; and changing the inner loss within the Miras template changes recall and perplexity .

Where the balance lies: the two sides measure different things. The equivalence holds for a class of architectures with linear final inner layers and was tested on large-chunk models; the gains for deep memories come from comparisons in which inner-model depth, objective and optimizer change together. The inspected evidence supports the narrower claim that the inner loop must run — freezing it is catastrophic — and leaves open whether its nonlinearity is necessary. A controlled comparison at matched parameters, data and kernel efficiency, varying only the depth and loss of the inner model, would distinguish the explanations.

9.2 Compression versus recall

Proposition: a fixed-size test-time memory can replace attention over the full context.

For language modeling loss the answer is close to yes: TTT-E2E keeps its loss gap to full attention flat from 8K to 128K, and several TTT-layer and delta-rule models match Transformers in perplexity at the 1B scale . For exact retrieval of a specific detail the answer is no in every inspected comparison: needle recall at 128K collapses for TTT-E2E, Gated DeltaNet and LaCT trail attention on real-world and long-context recall, and retrieval beyond 32K collapses to window level for every bounded-state model in one controlled study . Retrofitted hybrids that keep local attention and add neural memory retain pass-key retrieval to 32K , suggesting that the practical answer is a division of labour: attention for precise lookup within a window, test-time memory for what lies beyond it. The question is therefore not whether TTT memory compresses well, but which tasks tolerate compression.

9.3 Can self-derived signals add knowledge?

Proposition: a model training on rewards or text it generates itself can learn something it did not already know.

The test-time RL evidence says no in the limit and "yes, temporarily" in practice. Intrinsic rewards provably sharpen the initial distribution, and every configuration studied eventually collapses; early gains track how well the model's confidence already aligns with correctness . Exploration can delay collapse only at a cost in accuracy . In TTT layers and long-context models, updates on self-generated text measurably degrade loss on real text, and the damage disappears when the generator is held fixed . On the other side, TTRL's early gains generalize within benchmarks and can match supervised RL , and self-edits that are rewarded by downstream performance outperform data written by a stronger model . These results are compatible: self-derived signals redistribute probability mass toward answers the model already finds plausible, which helps when the model's majority is mostly right and hurts once that mass concentrates. Methods that inject external information — verifiers on related problems, labeled critics, held-out real text — are the ones that sustain improvement .

mermaid
flowchart LR M[Model weights] --> G[Generate answers or text] G --> S[Self-derived signal: majority vote, own text] S --> U[Weight update] U --> M X[External signal: verifier, related labeled tasks, held-out real text] --> A{Admission gate} U -.-> A A -->|accept| M

Figure 16. The closed loop behind Section 9.3. Without an external signal, the update reinforces whatever the current weights already generate, which is why self-derived rewards sharpen and eventually collapse; methods that sustain improvement add an external signal, either as the reward itself or as a gate on each update (schematic synthesized from ).

9.4 Why does TTT help without distribution shift?

TTT was introduced for distribution shift, yet nearest-neighbour TTT improves language models on in-distribution text . Three theoretical accounts have been proposed. Specialization after generalization argues that foundation models are globally underparameterized relative to the concepts in their data; training locally on a test point's neighbours temporarily reallocates capacity to the few relevant concepts, attains a minimax sparse-recovery rate with a small model, and helps even in distribution, with the advantage shrinking as models grow . A second line analyzes a single gradient step on in-context demonstrations for one-layer linear attention, derives the expected risk as a function of context length, test-time data and alignment between pre-training and target, and shows empirically that a tabular foundation model needs three to five times fewer in-context samples with TTT ; an extension proves that TTT lets a softmax-attention model learn nonlinear single-index tasks with test-time sample complexity independent of the ambient dimension . A decision-theoretic view treats few-step TTT in a restricted subspace as a spectral filter on prompt residuals, so the number of steps acts as a prior strength, and derives how far and in which directions to adapt . All three are proved in simplified settings — linear attention, linearized models, sparse concept spaces — and corroborated on small real tasks; none yet predicts the size of gains for large models on standard benchmarks.

9.5 What changes for safety?

Updating weights at inference turns the adaptation data into an attack surface. For classic TTT and TTA, a few dozen poisoned samples inserted into the test stream, crafted on a surrogate model without access to the target, sharply reduce accuracy, and TTT with a rotation task is the most fragile of the methods tested . For LLMs, letting an adversary supply the data for a few test-time LoRA steps raises attack success rates on seven open models from near zero to above 90%, and even self-supervised TTT on the clean prompt alone raises it severalfold; an in-context control with the same harmful demonstrations but no update stays low, so the update, not the context, does the work . Test-time RL amplifies whatever behaviour dominates the stream, which can make a model safer or more harmful depending on the injected prompts and can also destroy reasoning accuracy . The same capability is used offensively for automated red teaming . No inspected defence is both effective and cheap; the admission-test idea from Section 8.1 is one candidate that has not yet been evaluated against adversarial data.

Takeaways

  • Some TTT layers are provably linear attention with learned feature maps; the inner loop is indispensable, but whether its nonlinearity is remains unsettled.
  • Test-time memory matches attention on loss but not on exact long-range recall; hybrids divide the work.
  • Self-derived signals redistribute existing beliefs and eventually collapse; sustained gains need external signal.
  • Theory explains gains without shift as local specialization of an underparameterized model, so far only in simplified settings.
  • Test-time updates are an attack surface: poisoned streams and adversarial adaptation data defeat guardrails.

10 Benchmarks, Protocols and Released Resources

TTT has no benchmark of its own; each branch inherited the benchmarks of its parent field and added protocol choices that matter as much as the data. Table 7 lists the benchmarks that recur in the inspected papers, grouped by branch.

BranchBenchmarkWhat it measuresUsed by
Self-supervised TTTCIFAR-10-C / CIFAR-100-C, ImageNet-Caccuracy under 15 synthetic corruptions × 5 severities
Self-supervised TTTCIFAR-10.1, VisDA-Cnatural and sim-to-real shift
Self-supervised TTTModelNet-40C, ShapeNet-Cpoint-cloud corruptions
Online TTTCOCO Videos, KITTI-STEPsegmentation on long video streams
TTT layersWikiText / LAMBADA perplexity, commonsense suiteslanguage modeling at 0.1–3B scale
TTT layersRULER S-NIAH, BABILong, MQARlong-context and associative recall
TTT layers (vision, 3D)ImageNet-1K; Objaverse→GSO, DL3DVclassification; novel-view synthesis
LLM TTTARC-AGI-1 / -2, BIG-Bench Hardfew-shot rule induction
LLM TTTthe Pile (bits per byte)prompt-specific language modeling
LLM TTTLongBench-v2, ZeroScrolls, RULERlong-context understanding
Test-time RLAIME 2024/2025, AMC, MATH-500, GPQA-Diamondcompetition math and science reasoning
AgentsALFWorld, WebShop, SWE-bench Litelong-horizon agent tasks
AgentsEvo-Memoryimprovement along task streams
EmbodiedLIBERO; DMControl; NAVSIMmanipulation; visual control; driving

Table 7. Recurring benchmarks. Inclusion rule: benchmarks used as a main evaluation by at least one tier A or B work. Results on the same benchmark are comparable only under matched protocols (see below).

Protocol choices that change results. Four choices recur and are often reported inconsistently. (1) Episodic versus online: resetting after each input or carrying updates across a stream can change accuracy by tens of points in the same setting . (2) Single-pass versus multi-pass and source access: whether the method sees each test sample once and whether it may use source statistics define the realistic streaming protocols that make many classic results look weaker . (3) Transductive versus inductive adaptation in test-time RL: most methods train on the very questions they are scored on . (4) Budget accounting: TTT gains should be compared with matched inference compute, as some studies do for rollouts and FLOPs and others do not.

Released code and data. Among the deeply read works, code or project pages are stated for the original TTT method (https://test-time-training.github.io/) , TTT-MAE (https://yossigandelsman.github.io/ttt_mae/index.html) , TTT on video streams (https://video-ttt.github.io/, project page with result videos) , PAD (https://nicklashansen.github.io/PAD/) , MATE (https://github.com/jmiemirza/MATE) , NC-TTT (https://github.com/GustavoVargasHakim/NCTTT.git) and TTT for compressed sensing (https://github.com/MLI-lab/ttt_for_deep_learning_cs) . New benchmarks introduced by TTT papers include COCO Videos for streaming segmentation , navsafe for safety-critical driving , AdaptEval for LLM test-time learning , MolExp for chemical exploration and Evo-Memory for agents .

Takeaways

  • TTT reuses each parent field's benchmarks; robustness work centres on synthetic corruptions, architecture work on perplexity and recall, LLM work on ARC and long-context suites, test-time RL on competition math.
  • Episodic vs. online updates, source access, transductive evaluation and compute matching change results enough that cross-paper comparisons need them stated.

11 Applications

Applications rarely invent new TTT mechanisms; what changes from domain to domain is which test-time objective is available. Three patterns account for most of the applied literature: a physical or measurement-consistency loss that is exact for the domain, a domain-appropriate self-supervised task, and TTT layers used as an efficient backbone.

mermaid
flowchart LR A((Applications)) --> M[Medical imaging and clinical data · 65, 222–224] A --> S[Speech and audio · 64, 225, 226] A --> T[Time series and forecasting · 227, 228] A --> G[Graphs and recommendation · 63, 229, 230] A --> C[Science and engineering · 221, 231, 232]

Figure 17. Application areas with representative works.

Medical imaging and clinical data. Imaging inverse problems have an exact test-time signal: the reconstruction must agree with the acquired measurement. TTT for compressed-sensing MRI fits the network to that measurement-consistency loss and closes most of the quality gap caused by natural distribution shifts . MotionTTT applies the same principle to motion correction: with a reconstruction network trained only on motion-free data and frozen, it optimizes only the rigid motion parameters of each shot to minimize data inconsistency, matches a known-motion oracle in simulation across severities and runs about six times faster than alternating optimization; a theorem guarantees a global minimum at the true motion in a simplified signal model . Other medical applications include image registration, PET denoising, 4D interpolation, multimodal fusion, interactive tumor segmentation, EEG foundation models, clinical time series and ventilation prediction, and TTT-layer segmentation backbones .

Speech and audio. A mel-spectrogram MAE gives speech a self-supervised task, and bias-only updates make TTT stable for speaker identification and emotion recognition under noise and speaker shifts . Instance-specific TTT has been applied to speech enhancement, speech editing, packet-loss concealment and speech emotion recognition with Titans-style memory , and test-time RL to audio question answering and speech recognition (Chapter 7).

Time series. Replacing the Mamba blocks of a forecasting model with TTT blocks gives a near-tie overall on standard long-term forecasting benchmarks, winning half of the MSE cells, with gains concentrated on larger multichannel datasets and long look-back windows . Applications include self-adaptive forecasting, radar echo extrapolation and an audit showing that delayed labels change how TTA for forecasting should be evaluated .

Graphs, recommendation and information systems. Beyond graph classification (Section 4.4), TTT has been used for graph anomaly detection, temporal knowledge-graph reasoning, LLM-assisted graph adaptation, information-diffusion prediction and fake-news detection . In recommendation it adapts to user-interest shift, with both self-supervised updates and TTT layers .

Science and engineering. A study of RL fine-tuning of a chemical language model on one scoring task, framed as TTT, finds that spending a fixed molecule budget on many independent agents beats spending it on one longer run, roughly doubling the benchmark's summed rediscovery score (3.52 against 1.70 at an equal total of 1.28M molecules) . TTT has also been applied to power-flow surrogates, machine-learned force fields, protein fitness, mass-spectrum prediction, battery health, geophysical inversion, Earth observation and noisy quantum circuits .

Takeaways

  • Domains with an exact consistency signal (imaging inverse problems, physics constraints) give TTT its cleanest wins.
  • Elsewhere, applications transplant a self-supervised task or a TTT-layer backbone; evidence is mostly single-paper and benchmark-specific.

12 Future Directions

The following open problems are derived from the evidence in the preceding chapters. Each names the evidence that exposed it, early work pointing at it, and a check that would reduce uncertainty. They are the authors' inference, not results from the literature.

mermaid
flowchart LR G[Gate every update with external evidence] --> S[Safe and stable deployment-time learning] N[Isolate what the inner loop's nonlinearity buys] --> A[Architectures] H[Hybrid memory with explicit division of labour] --> A B[Compute-matched accounting against test-time scaling] --> E[Evaluation] P[Persistent learning without forgetting] --> S T[Theory beyond linear and convex settings] --> E

Figure 18. Open problems grouped by what they would improve.

1. Admission control for test-time updates. Self-generated feedback degrades long-horizon TTT, test-time RL collapses onto the initial majority, and adversarial adaptation data defeats guardrails . Early answers gate updates by verifiers or by a held-out real-text test . A useful check is a shared benchmark in which the same admission rule is evaluated against both benign self-generated drift and adversarial adaptation data.

2. What the inner loop's nonlinearity buys. The linear-attention equivalence and the deep-memory gains are both supported under different conditions (Section 9.1) . A matched study that varies only inner-model depth and inner loss at fixed parameters, data, chunk size and kernel efficiency, and evaluates both perplexity and exact recall, would settle much of the dispute.

3. Hybrid memory as a design principle. Test-time memory matches attention on loss but loses exact recall; retrofitted hybrids keep recall . Open questions are how to allocate capacity between windowed attention and fast weights and how to decide per token which one should store it; layers that write only the residual not explained by an explicit memory are one early approach .

4. Compute-matched comparison with test-time scaling. TTT competes with sampling, search and longer contexts for the same inference budget. Some studies match rollouts or FLOPs , many do not. Reporting gains as a function of inference FLOPs and wall-clock, against the best non-updating use of the same budget, would make the field's central claim — that gradient steps are a good use of inference compute — testable across papers.

5. Persistent learning without forgetting. Most LLM and agent TTT methods reset adapters per task or episode; persistent variants report forgetting under sequential updates , and online classic TTT depends on temporal smoothness . Measuring retention of earlier capabilities along long deployment streams, as some agent benchmarks begin to do , is a prerequisite for TTT that accumulates rather than adapts.

6. Theory at the scale of practice. Current theory explains gains for linear attention, sparse concept models and linearized networks . Predicting from measurable quantities (for example gradient alignment, as in the original TTT analysis ) when TTT will help a large model on a given input, and by how much, remains open; a check is whether such a predictor can select which inputs to adapt on, as one agent method does heuristically with a confidence margin .

13 Conclusion

Test-time training began as a way for an image classifier to learn from a single corrupted test image and has become a common structure across machine learning: an inner learning problem, defined on test-time data, solved during inference and shaped by an outer loop during training. Organizing the field by what the inner loop learns and from which signal makes the branches comparable. Self-supervised TTT works when an auxiliary gradient aligns with the main task. TTT layers turn a sequence model's state into an online regressor and have improved steadily from additive linear attention to gated delta rules, deep neural memories and exact solvers, matching attention on loss but not on exact long-range recall. Language models gain from fine-tuning on a test task's demonstrations, on retrieved data or on their own context, at substantial inference cost. Test-time reinforcement learning with self-derived rewards produces large early gains that are bounded by the model's prior and collapse with continued training. Agents and robots learn from deployment experience most reliably when an external signal gates each update.

Across branches the same lessons recur: the inner loop must have a signal that carries information the model lacks, updates driven only by the model's own outputs redistribute rather than add knowledge, and the ability to change weights at inference is also an attack surface. The open problems — admission control for updates, isolating what nonlinear inner learning contributes, hybrid memory, compute-matched evaluation, persistent learning and theory at practical scale — are where the field's central claim, that learning at test time is a good use of inference compute, will be tested.

Appendix: Scope and Evidence Boundary

Retrieval. The library is an index of arXiv papers. Candidates were gathered on 4 November 2026 through four routes restricted, for the semantic routes, to the cs, stat and eess archives: a keyword route on test-time training and its variants in titles and abstracts (488 papers); three semantic routes on classic TTT, TTT layers and test-time memorization, and test-time training and RL of LLMs (top 2,000, 1,500 and 1,500 of 3,000-deep rankings, chosen after inspecting tail pages); and 7 anchor papers resolved by title. Their union contained 4,820 papers.

Screening. A calibrated model judge screened the union against a broad inclusion criterion (learning at test time by weight or fast-weight updates, including fully test-time adaptation), keeping 1,086 papers. A second screen with the narrow criterion of this survey, which excludes fully test-time adaptation by entropy, pseudo-labels, normalization statistics or teacher–student consistency, kept 587. An audit of rejected papers whose abstracts mention test-time training, test-time memorization or fast weights restored 18 papers, including Titans, Miras, Gated DeltaNet, the parallel DeltaNet algorithm, SEAL, PAD and TTT3R, giving a corpus of 605 papers. About five title-level TTT papers rejected in the first screen were judged borderline and not restored.

Reading depth. 94 papers (25 tier A, 69 tier B) were read at section level through per-paper evidence briefs; reading provenance records the sections inspected for each. All other cited works are tier C, cited for what their abstracts state; the survey on self-improving test-time intelligence was additionally read directly in its introduction and part of its test-time learning section to position this survey. The bibliography contains 256 works: 94 at section level and 162 at abstract level. Tier A and B works carry all mechanism descriptions and numbers in the text.

Thin leaves and limits. Evidence is thinnest for embodied TTT (mostly simulation or few real trials), for applications (mostly single papers per domain) and for safety (a handful of studies). Most numbers are single-run results reported by the authors under their own protocols; comparisons across papers are qualitative unless the text states matched conditions. The library's arXiv coverage means work published only at venues without an arXiv version may be missing.

References

[1] Yu Sun, Xiaolong Wang, Zhuang Liu, John Miller, Alexei A. Efros, Moritz Hardt. Test-Time Training with Self-Supervision for Generalization under Distribution Shifts. 2019. arXiv preprint. arXiv:1909.13231

[2] Yu Sun, Xinhao Li, Karan Dalal, et al.. Learning to (Learn at Test Time): RNNs with Expressive Hidden States. 2024. ICML 2025. arXiv:2407.04620

[3] Ali Behrouz and Peilin Zhong and Vahab Mirrokni. Titans: Learning to Memorize at Test Time. 2024. NeurIPS 2025. arXiv:2501.00663

[4] Karan Dalal, Daniel Koceja, Gashon Hussein, et al.. One-Minute Video Generation with Test-Time Training. 2025. CVPR 2025. arXiv:2504.05298

[5] Ekin Aky"urek, Mehul Damani, Adam Zweiger, et al.. The Surprising Effectiveness of Test-Time Training for Few-Shot Learning. 2024. arXiv preprint. arXiv:2411.07279

[6] Yuxin Zuo, Kaiyan Zhang, Li Sheng, et al.. TTRL: Test-Time Reinforcement Learning. 2025. NeurIPS 2025. arXiv:2504.16084

[7] Mert Yuksekgonul, Daniel Koceja, Xinhao Li, et al.. Learning to Discover at Test Time. 2026. arXiv preprint. arXiv:2601.16175

[8] Dequan Wang, Evan Shelhamer, Shaoteng Liu, Bruno Olshausen, Trevor Darrell. Tent: Fully Test-time Adaptation by Entropy Minimization. 2020. arXiv preprint. arXiv:2006.10726

[9] Jian Liang and Ran He and Tieniu Tan. A Comprehensive Survey on Test-Time Adaptation under Distribution Shifts. 2023. IJCV 2025. doi:10.1007/s11263-024-02181-w arXiv:2303.15361

[10] Zehao Xiao, Cees G. M. Snoek. Beyond Model Adaptation at Test Time: A Survey. 2024. arXiv preprint. arXiv:2411.03687

[11] Zixin Wang, Yadan Luo, Liang Zheng, Zhuoxiao Chen, Sen Wang, Zi Huang. In Search of Lost Online Test-time Adaptation: A Survey. 2023. IJCV 2025. arXiv:2310.20199

[12] Qiyuan Zhang, Fuyuan Lyu, Zexu Sun, et al.. A Survey on Test-Time Scaling in Large Language Models: What, How, Where, and How Well?. 2025. arXiv preprint. arXiv:2503.24235

[13] Yongyi Su, Xun Xu, Tianrui Li, Kui Jia. Revisiting Realistic Test-Time Training: Sequential Inference and Adaptation by Anchored Clustering Regularized Self-Training. 2023. IEEE TPAMI 2024. arXiv:2303.10856

[14] Chen Tao, Li Shen, Soumik Mondal. Meta-TTT: A Meta-learning Minimax Framework For Test-Time Training. 2024. ICMLA 2025. arXiv:2410.01709

[15] Rachit Bansal, Aston Zhang, Rishabh Tiwari, et al.. Let's (not) just put things in Context: Test-Time Training for Long-Context LLMs. 2025. ICLR 2026. arXiv:2512.13898

[16] Shuaicheng Niu, Guohao Chen, Yaofo Chen, et al.. A Survey on Self-Improving Test-Time Intelligence: Feedback-Driven Adapting, Learning, and Scaling at Inference. 2026. arXiv preprint. doi:10.1007/s11633-026-1694-1 arXiv:2609.01679

[17] Imanol Schlag, Kazuki Irie, J"urgen Schmidhuber. Linear Transformers Are Secretly Fast Weight Programmers. 2021. arXiv preprint. arXiv:2102.11174

[18] Ke Alexander Wang, Jiaxin Shi, Emily B. Fox. Test-time regression: a unifying framework for designing sequence models with associative memory. 2025. arXiv preprint. arXiv:2501.12352

[19] Yossi Gandelsman, Yu Sun, Xinlei Chen, Alexei A. Efros. Test-Time Training with Masked Autoencoders. 2022. NeurIPS 2022. arXiv:2209.07522

[20] Renhao Wang, Yu Sun, Arnuv Tandon, et al.. Test-Time Training on Video Streams. 2023. JMLR 2025. arXiv:2307.05014

[21] Moritz Hardt and Yu Sun. Test-Time Training on Nearest Neighbors for Large Language Models. 2023. ICLR 2024. arXiv:2305.18466

[22] Ali Behrouz and Meisam Razaviyayn and Peilin Zhong, and Vahab Mirrokni. It's All Connected: A Journey Through Test-Time Memorization, Attentional Bias, Retention, and Online Optimization. 2025. ICLR 2026. arXiv:2504.13173

[23] Tianyuan Zhang, Sai Bi, Yicong Hong, et al.. Test-Time Training Done Right. 2025. ICLR 2026. arXiv:2505.23884

[24] Arnuv Tandon, Karan Dalal, Xinhao Li, et al.. End-to-End Test-Time Training for Long Context. 2025. arXiv preprint. arXiv:2512.23675

[25] Guhao Feng, Shengjie Luo, Kai Hua, et al.. In-Place Test-Time Training. 2026. ICLR 2026. arXiv:2604.06169

[26] Haodong Lu, Dong Gong. ASCENT: Online Test-Time Training of Long-Horizon Agents via Self-Distillation of Verified Experience. 2026. arXiv preprint. arXiv:2610.05303

[27] Junyi Wu, Zekun Li, Chenhongyi Yang, et al.. World-T3: Test-Time Training as Persistent Memory for Real-Time Video World Models. 2026. arXiv preprint. arXiv:2610.17434

[28] Nicklas Hansen, Rishabh Jangir, Yu Sun, et al.. Self-Supervised Policy Adaptation during Deployment. 2020. ICLR 2021. arXiv:2007.04309

[29] Songlin Yang, Jan Kautz, Ali Hatamizadeh. Gated Delta Networks: Improving Mamba2 with Delta Rule. 2024. ICLR 2025. arXiv:2412.06464

[30] Parsa Omidi, Xingshuai Huang, Axel Laborieux, Bahareh Nikpour, Tianyu Shi, and Armaghan Eshaghi. Memory-Augmented Transformers: A Systematic Review from Neuroscience Principles to Enhanced Model Architectures. 2025. arXiv preprint. arXiv:2508.10824

[31] Kazuki Irie and Samuel J. Gershman. Fast weight programming and linear transformers: from machine learning to neurobiology. 2025. TMLR 2026. arXiv:2508.08435

[32] Gustavo A. Vargas Hakim and David Osowiechi and Mehrdad Noori and Milad Cheraghalikhani and Ismail Ben Ayed and Christian Desrosiers. ClusT3: Information Invariant Test-Time Training. 2023. ICCV 2023. arXiv:2310.12345

[33] Alexander Bartler, Andre B"uhler, Felix Wiewel, Mario D"obler and Bin Yang. MT3: Meta Test-Time Training for Self-Supervised Test-Time Adaption. 2021. AISTATS 2022. arXiv:2103.16201

[34] Ferran Alet, Maria Bauza, Kenji Kawaguchi, Nurullah Giray Kuru, Tomas Lozano-Perez, Leslie Pack Kaelbling. Tailoring: encoding inductive biases by optimizing unsupervised objectives at prediction time. 2020. NeurIPS 2021. arXiv:2009.10623

[35] M. Jehanzeb Mirza, Inkyu Shin, Wei Lin, et al.. MATE: Masked Autoencoders are Online 3D Test-Time Learners. 2022. ICCV 2023. arXiv:2211.11432

[36] Bo Liu, Rui Wang, Lemeng Wu, Yihao Feng, Peter Stone, Qiang Liu. Longhorn: State Space Models are Amortized Online Learners. 2024. ICLR 2025. arXiv:2407.14207

[37] Ali Behrouz and Zeman Li and Praneeth Kacham and Majid Daliri and Yuan Deng and Peilin Zhong and Meisam Razaviyayn and Vahab Mirrokni. ATLAS: Learning to Optimally Memorize the Context at Test Time. 2025. arXiv preprint. arXiv:2505.23735

[38] Ali Behrouz and Meisam Razaviyayn and Peilin Zhong and Vahab Mirrokni. Nested Learning: The Illusion of Deep Learning Architectures. 2025. NeurIPS 2025. arXiv:2512.24695

[39] Zeman Li, Ali Behrouz, Yuan Deng, et al.. TNT: Improving Chunkwise Training for Test-Time Memorization. 2025. ICLR 2026. arXiv:2511.07343

[40] Noel Loo, Neehal Tumma, T. Konstantin Rusch, Mathias Lechner, Alexander Amini, Daniela Rus. ParaTTT: Parallelizing Test-Time Training Layers with Deep Memories. 2026. arXiv preprint. arXiv:2610.38255

[41] Dongchen Han, Yining Li, Tianyu Li, et al.. ViT3^3: Unlocking Test-Time Training in Vision. 2025. CVPR 2026. arXiv:2512.01643

[42] Xingyu Chen, Yue Chen, Yuliang Xiu, Andreas Geiger, Anpei Chen. TTT3R: 3D Reconstruction as Test-Time Training. 2025. ICLR 2026. arXiv:2509.26645

[43] Keya Hu, Ali Cy, Linlu Qiu, et al.. ARC Is a Vision Problem!. 2025. CVPR 2026. arXiv:2511.14761

[44] Yang Hu, Xingyu Zhang, Xueji Fang, et al.. SLOT: Sample-specific Language Model Optimization at Test-time. 2025. arXiv preprint. arXiv:2505.12392

[45] Jonas H"ubotter, Sascha Bongni, Ido Hakimi, Andreas Krause. Efficiently Learning at Test-Time: Active Fine-Tuning of LLMs. 2024. ICLR 2025. arXiv:2410.08020

[46] Zeming Chen, Angelika Romanou, Gail Weiss, Antoine Bosselut. PERK: Long-Context Reasoning as Test-Time Learning. 2025. ICLR 2026. arXiv:2507.06415

[47] Yiping Wang, Shao-Rong Su, Zhiyuan Zeng, et al.. ThetaEvolve: Test-time Learning on Open Problems. 2025. arXiv preprint. arXiv:2511.23473

[48] Akshit Singh, Shyam Marjit, Wei Lin, et al.. TTRV: Test-Time Reinforcement Learning for Vision Language Models. 2025. CVPR 2026. arXiv:2510.06783

[49] Bingxiang He, Yuxin Zuo, Zeyuan Liu, et al.. How Far Can Unsupervised RLVR Scale LLM Training?. 2026. ICLR 2026. arXiv:2603.08660

[50] Jaeho Hwang, Uiwon Hwang. When Does Exploration Prevent Collapse? Three Regimes and the Path of the Reward in Self-Consistency Training. 2026. arXiv preprint. arXiv:2611.01307

[51] Weiqin Wang, Yile Wang, Kehao Chen, Hui Huang. Beyond Majority Voting: Towards Fine-grained and More Reliable Reward Signal for Test-Time Reinforcement Learning. 2025. ACL 2026. arXiv:2512.15146

[52] Jonas H"ubotter, Leander Diaz-Bone, Ido Hakimi, Andreas Krause, Moritz Hardt. Learning on the Job: Test-Time Curricula for Targeted Reinforcement Learning. 2025. arXiv preprint. arXiv:2510.04786

[53] Qingyang Zhang, Xinke Kong, Haitao Wu, et al.. TEMPO: Scaling Test-time Training for Large Reasoning Models. 2026. arXiv preprint. arXiv:2604.19295

[54] Adam Zweiger, Jyothish Pari, Han Guo, Ekin Aky"urek, Yoon Kim, Pulkit Agrawal. Self-Adapting Language Models. 2025. NeurIPS 2025. arXiv:2506.10943

[55] Yanbo Wang, Jinhua Hao, Yuze Shi, Kun Yuan, Ming Sun. No Time Like the Present: Agentic Test-Time Training for LLM Agents. 2026. arXiv preprint. arXiv:2607.03441

[56] Zechen Bai, Chen Gao, Mike Zheng Shou. EVOLVE-VLA: Test-Time Training from Environment Feedback for Vision-Language-Action Models. 2025. arXiv preprint. arXiv:2512.14666

[57] Chonghao Sima, Kashyap Chitta, Zhiding Yu, et al.. Centaur: Robust End-to-End Autonomous Driving with Test-Time Training. 2025. arXiv preprint. arXiv:2503.11650

[58] Zheyuan Zhang, Suyu Ye, Nakul Agarwal, et al.. JEPA-TTT: Persistent Test-Time Training of Latent World Models for Planning under Dynamics Shifts. 2026. arXiv preprint. arXiv:2610.00722

[59] Haoxuan Wang, Gengyu Zhang, Ramana Rao Kompella, Gaowen Liu, Yan Yan. Test-Time Training as Residual Memory for Robot Policies. 2026. arXiv preprint. arXiv:2610.04701

[60] Xuan Ouyang, Zefan Cai, Junjie Hu. Test-Time Training with Next-Token Prediction. 2026. arXiv preprint. arXiv:2606.21803

[61] David Osowiechi, Gustavo A. Vargas Hakim, Mehrdad Noori, Milad Cheraghalikhani, Ismail Ben Ayed, Christian Desrosiers. TTTFlow: Unsupervised Test-Time Training with Normalizing Flow. 2022. WACV 2023. arXiv:2210.11389

[62] David Osowiechi and Gustavo A. Vargas Hakim and Mehrdad Noori and Milad Cheraghalikhani and Ali Bahri and Moslem Yazdanpanah and Ismail Ben Ayed and Christian Desrosiers. NC-TTT: A Noise Contrastive Approach for Test-Time Training. 2024. arXiv preprint. arXiv:2404.08392

[63] Yiqi Wang, Chaozhuo Li, Wei Jin, et al.. Test-Time Training for Graph Neural Networks. 2022. DASFAA 2025. arXiv:2210.08813

[64] Sri Harsha Dumpala and Chandramouli Sastry and Sageev Oore. Test-Time Training for Speech. 2023. arXiv preprint. arXiv:2309.10930

[65] Mohammad Zalbagi Darestani, Jiayu Liu, and Reinhard Heckel. Test-Time Training Can Close the Natural Distribution Shift Performance Gap in Deep Learning Based Compressed Sensing. 2022. arXiv preprint. arXiv:2204.07204

[66] Marco Colussi, Sergio Mascetti, Jose Dolz, Christian Desrosiers. ReC-TTT: Contrastive Feature Reconstruction for Test-Time Training. 2024. WACV 2025. arXiv:2411.17869

[67] Nikita Durasov, Assaf Shocher, Doruk Oner, Gal Chechik, Alexei A. Efros, Pascal Fua. IT3^3: Idempotent Test-Time Training. 2024. ICML 2025. arXiv:2410.04201

[68] Bochao Zhang, Rui Shao, Jingda Du, PC Yuen. Mixup for Test-Time Training. 2022. arXiv preprint. arXiv:2210.01640

[69] Aneeshan Sain, Ayan Kumar Bhunia, Vaishnav Potlapalli, Pinaki Nath Chowdhury, Tao Xiang, Yi-Zhe Song. Sketch3T: Test-Time Training for Zero-Shot SBIR. 2022. CVPR 2022. arXiv:2203.14691

[70] Soumava Paul, Titir Dutta, Aheli Saha, Abhishek Samanta, Soma Biswas. Test-time Training for Data-efficient UCDR. 2022. arXiv preprint. arXiv:2208.09198

[71] Yunlong Zhang and Yuxuan Sun and Sunyi Zheng and Zhongyi Shui and Chenglu Zhu and Lin Yang. Test-Time Training for Semantic Segmentation with Output Contrastive Loss. 2023. arXiv preprint. arXiv:2311.07877

[72] Weihuang Liu, Xi Shen, Haolun Li, et al.. Depth-aware Test-Time Training for Zero-shot Video Object Segmentation. 2024. CVPR 2024. arXiv:2403.04258

[73] Lisa Weijler and Muhammad Jehanzeb Mirza and Leon Sick and Can Ekkazan and Pedro Hermosilla. TTT-KD: Test-Time Training for 3D Semantic Segmentation through Knowledge Distillation from Foundation Models. 2024. 3DV 2025. arXiv:2403.11691

[74] Weihuang Liu, Xi Shen, Chi-Man Pun, Xiaodong Cun. ForgeryTTT: Zero-Shot Image Manipulation Localization with Test-Time Training. 2024. arXiv preprint. arXiv:2410.04032

[75] Wenhao Gu, Li Gu, Ziqiang Wang, Ching Yee Suen, Yang Wang. DocTTT: Test-Time Training for Handwritten Document Recognition Using Meta-Auxiliary Learning. 2025. WACV 2025. arXiv:2501.12898

[76] Hannuo Zhang, Zhixiang Chi, Yang Wang, Xinxin Zuo. MVS-TTA: Test-Time Adaptation for Multi-View Stereo via Meta-Auxiliary Learning. 2025. arXiv preprint. arXiv:2511.18120

[77] Ahmed Hatem, Yiming Qian, Yang Wang. Point-TTA: Test-Time Adaptation for Point Cloud Registration Using Multitask Meta-Auxiliary Learning. 2023. ICCV 2023. arXiv:2308.16481

[78] Gabriele Valvano, Andrea Leo, Sotirios A. Tsaftaris. Re-using Adversarial Mask Discriminators for Test-time Training under Distribution Shifts. 2021. Journal of Machine Learning for Biomedical Imaging (MELBA), 2022. doi:10.59275/j.melba.2022-bd5e arXiv:2108.11926

[79] Samuel Barbeau, Pedram Fekri, David Osowiechi, et al.. CTA: Cross-Task Alignment for Better Test Time Training. 2025. arXiv preprint. arXiv:2507.05221

[80] Wooseong Jeong, Jegyeong Cho, Youngho Yoon, Kuk-Jin Yoon. Synchronizing Task Behavior: Aligning Multiple Tasks during Test-Time Training. 2025. ICCV 2025. arXiv:2507.07778

[81] Houcheng Su, Mengzhu Wang, Jiao Li, Bingli Wang, Daixian Liu, Zeheng Wang. Open-World Test-Time Training: Self-Training with Contrast Learning. 2024. arXiv preprint. arXiv:2409.09591

[82] Qiongjie Cui, Huaijiang Sun, Jianfeng Lu, Bin Li, Weiqing Li. Meta-Auxiliary Learning for Adaptive Human Pose Prediction. 2023. AAAI 2023. arXiv:2304.06411

[83] Jonathan Swinnen, Tinne Tuytelaars. Remembering by Reconstructing: Domain Incremental Learning With Test-Time Training on Video Streams. 2026. arXiv preprint. arXiv:2605.31108

[84] Rajat Modi, Sebastian Noel, Xin Liang, Yogesh Singh Rawat. Forget, Anticipate and Adapt: Test Time Training for Long Videos. 2026. ECCV 2026. arXiv:2606.26515

[85] Jiaming Liu, Ran Xu, Senqiao Yang, et al.. Continual-MAE: Adaptive Distribution Masked Autoencoders for Continual Test-Time Adaptation. 2023. CVPR 2024. arXiv:2312.12480

[86] Guixian Xu, Jinglai Li, Junqi Tang. Equivariant Test-Time Training with Operator Sketching for Imaging Inverse Problems. 2024. arXiv preprint. arXiv:2411.05771

[87] Edward P. Chandler, Shirin Shoushtari, Jiaming Liu, M. Salman Asif, and Ulugbek S. Kamilov. Overcoming Distribution Shifts in Plug-and-Play Methods with Test-Time Training. 2024. CAMSAP 2023. doi:10.1109/CAMSAP58249.2023.10403502 arXiv:2403.10374

[88] Songlin Yang, Bailin Wang, Yu Zhang, Yikang Shen, Yoon Kim. Parallelizing Linear Transformers with the Delta Rule over Sequence Length. 2024. NeurIPS 2024. arXiv:2406.06484

[89] Mahdi Karami, Razvan Pascanu, Vahab Mirrokni. Lattice: Learning to Efficiently Compress the Memory. 2025. arXiv preprint. arXiv:2504.05646

[90] Johannes von Oswald, Nino Scherrer, Seijin Kobayashi, et al.. MesaNet: Sequence Modeling by Locally Optimal Test-Time Training. 2025. ICLR 2026. arXiv:2506.05233

[91] Liangzu Peng, Aditya Chattopadhyay, Luca Zancato, Elvis Nunez, Wei Xia, Stefano Soatto. Gated KalmaNet: A Fading Memory Layer Through Test-Time Ridge Regression. 2025. CVPR 2026. arXiv:2511.21016

[92] Zeyun Zhong, Joya Chen, Manuel Martin, Frederik Diederichs, Juergen Gall, Juergen Beyerer. Rethinking Expressivity and Efficiency in Test-Time Training. 2026. arXiv preprint. arXiv:2608.21308

[93] Chen Wang, Hao Tan, Wang Yifan, et al.. tttLRM: Test-Time Training for Long Context and Autoregressive 3D Reconstruction. 2026. CVPR 2026. arXiv:2602.20160

[94] Imanol Schlag, Tsendsuren Munkhdalai, J"urgen Schmidhuber. Learning Associative Inference Using Fast Weight Memory. 2020. ICLR 2021. arXiv:2011.07831

[95] Kazuki Irie, Imanol Schlag, R'obert Csord'as, J"urgen Schmidhuber. Going Beyond Linear Transformers with Recurrent Fast Weight Programmers. 2021. NeurIPS 2021. arXiv:2106.06295

[96] Kevin Clark, Kelvin Guu, Ming-Wei Chang, Panupong Pasupat, Geoffrey Hinton, Mohammad Norouzi. Meta-Learning Fast Weight Language Models. 2022. EMNLP 2022. arXiv:2212.02475

[97] Julien Siems, Timur Carstensen, Arber Zela, Frank Hutter, Massimiliano Pontil, Riccardo Grazzi. DeltaProduct: Improving State-Tracking in Linear RNNs via Householder Products. 2025. arXiv preprint. arXiv:2502.10297

[98] Ali Hatamizadeh, Yejin Choi and Jan Kautz. Gated DeltaNet-2: Decoupling Erase and Write in Linear Attention. 2026. arXiv preprint. arXiv:2605.22791

[99] Jiaxi Hu, Yongqi Pan, Jusen Du, et al.. Comba: Improving Bilinear RNNs with Closed-loop Control. 2025. arXiv preprint. arXiv:2506.02475

[100] Neehal Tumma, Noel Loo, Daniela Rus. Preconditioned DeltaNet: Curvature-aware Sequence Modeling for Linear Recurrences. 2026. arXiv preprint. arXiv:2604.21100

[101] Jiaxuan Zou, Ruifeng Ren, Yong Liu. Kaczmarz Linear Attention. 2026. arXiv preprint. arXiv:2605.08587

[102] Gavriel Di Nepi, Federico Siciliano, Fabrizio Silvestri. Titans Revisited: A Lightweight Reimplementation and Critical Analysis of a Test-Time Memory Model. 2025. arXiv preprint. arXiv:2510.09551

[103] Mahdi Karami, Ali Behrouz, Praneeth Kacham, Vahab Mirrokni. Trellis: Learning to Compress Key-Value Memory in Attention Models. 2025. arXiv preprint. arXiv:2512.23852

[104] Yuri Kuratov, Matvey Kairov, Aydar Bulatov, Ivan Rodkin, Mikhail Burtsev. GradMem: Learning to Write Context into Memory with Test-Time Gradient Descent. 2026. arXiv preprint. arXiv:2603.13875

[105] Lingrui Mei, Shenghua Liu, Yiwei Wang, et al.. Gated Differentiable Working Memory for Long-Context Language Modeling. 2026. ACL 2026. arXiv:2601.12906

[106] Tianyu Zhao and Llion Jones. Fast-weight Product Key Memory. 2026. arXiv preprint. arXiv:2601.00671

[107] Jingdi Lei, Di Zhang, Junxian Li, et al.. δ\delta-mem: Efficient Online Memory for Large Language Models. 2026. arXiv preprint. arXiv:2605.12357

[108] Wonguk Cho, Kyubyung Chae, Tribhuvanesh Orekondy, et al.. MoNe: Modular Neural Memory for Efficient Long Context Inference. 2026. arXiv preprint. arXiv:2608.17616

[109] Zefan Cai, Qinzhe Hu, Ziqiao Ma, Hao Tan, Junjie Hu. Universal Test-Time Training. 2026. arXiv preprint. arXiv:2610.05484

[110] Bohao Tang, Zhen Qin, Yuqi Pan, Zheng Li, Pengfei Liu, Ya Zhang. Modular TTT: Rethinking Test-Time Training as Composable Modules. 2026. arXiv preprint. arXiv:2608.07110

[111] Jian Yang, Zhizhuo Kou, Yao Tian, et al.. RW-TTT: Batched Serving for Request-Owned Test-Time Training State. 2026. arXiv preprint. arXiv:2605.28053

[112] Bo Liu, Qiang Liu. GradLev: Token-Parallel Test-Time Training Via Costate Prediction. 2026. arXiv preprint. arXiv:2609.34174

[113] Yining Li, Dongchen Han, Jie Fu, Gao Huang. DeltaTTT: Layerwise Optimization for Nonlinear Recurrent Memory. 2026. arXiv preprint. arXiv:2610.08553

[114] Sarah Pan, Ali Behrouz. Titan-Llama: Retrofitting Pre-trained LLMs with External Neural Memory Modules. 2026. arXiv preprint. arXiv:2610.19210

[115] Jiashu Xu. Med-TTT: Vision Test-Time Training model for Medical Image Segmentation. 2024. arXiv preprint. arXiv:2410.02523

[116] Bohao Xing, Kaishen Yuan, Zitong Yu, Xin Liu, Heikki K"alvi"ainen. AU-TTT: Vision Test-Time Training model for Facial Action Unit Detection. 2025. ICME 2025. arXiv:2503.23450

[117] Xiang Zhao. Spectral-spatial vision test-time training for hyperspectral image classification. 2026. arXiv preprint. arXiv:2611.02364

[118] Sharukshan Niranjan, Oshadha Samarakoon, Nichula Wasalathilaka, Roshan Godaliyadda, Parakrama Ekanayake, Vijitha Herath. ChangeT3^3: Evaluating Vision Test-Time Training for Remote Sensing Change Detection. 2026. arXiv preprint. arXiv:2610.15813

[119] Yining Li, Dongchen Han, Zeyu Liu, Hanyi Wang, Yulin Wang, Gao Huang. Linearizing Vision Transformer with Test-Time Training. 2026. arXiv preprint. arXiv:2605.02772

[120] Quan Kong, Yanru Xiao, Yuhao Shen, Cong Wang. Vision-TTT: Efficient and Expressive Visual Representation Learning with Test-Time Training. 2026. ECCV 2026. arXiv:2603.00518

[121] Tao Xie, Peishan Yang, Yudong Jin, et al.. Scal3R: Scalable Test-Time Training for Large-Scale 3D Reconstruction. 2026. CVPR 2026. arXiv:2604.08542

[122] Haian Jin, Rundi Wu, Tianyuan Zhang, et al.. ZipMap: Linear-Time Stateful 3D Reconstruction via Test-Time Training. 2026. CVPR 2026. arXiv:2603.04385

[123] Junyi Zhang, Charles Herrmann, Junhwa Hur, et al.. LoGeR: Long-Context Geometric Reconstruction with Hybrid Memory. 2026. arXiv preprint. arXiv:2603.03269

[124] Sven Elflein, Ruilong Li, S'ergio Agostinho, et al.. VGG-T3^3: Offline Feed-Forward 3D Reconstruction at Scale. 2026. CVPR 2026. arXiv:2602.23361

[125] Ziqiao Ma, Xueyang Yu, Haoyu Zhen, Yuncong Yang, Joyce Chai, Chuang Gan. Fast Spatial Memory with Elastic Test-Time Training. 2026. arXiv preprint. arXiv:2604.07350

[126] Fangfu Liu, Diankun Wu, Jiawei Chi, et al.. Spatial-TTT: Streaming Visual-based Spatial Intelligence with Test-Time Training. 2026. ECCV 2026. arXiv:2603.12255

[127] Mahmoud Ahmed, Sameh Abdulah, Olatunji Ruwase, Sam Ade Jacobs, Mathis Bode, Mohamed Elhoseiny. LongVU-TTT: Causal Test-Time Training for Visual Resampling in Long Video Understanding. 2026. arXiv preprint. arXiv:2608.25729

[128] Zhuoming Liu, Jinhong Lin, Lin Zhang, Yiwu Zhong, Yin Li. Memory as Weights: Internalizing Long-Term History for Streaming Videos. 2026. arXiv preprint. arXiv:2610.22070

[129] Haonan Zhao, Jiaxuan Chen, Qingyang Liu, et al.. Memory Internalization via Test-Time Training for Long-Video Understanding. 2026. arXiv preprint. arXiv:2610.26910

[130] Jinwu Hu, Zhitian Zhang, Guohao Chen, et al.. Test-Time Learning for Large Language Models. 2025. ICML 2025. arXiv:2505.20633

[131] Amal Rannen-Triki, Jorg Bornschein, Razvan Pascanu, et al.. Revisiting Dynamic Evaluation: Online Adaptation for Large Language Models. 2024. arXiv preprint. arXiv:2403.01518

[132] Adrien Deliege and Marc Van Droogenbroeck. Pretraining and Test-Time Training Budgets Matter for ARC: A Controlled Study of VARC and TRM. 2026. arXiv preprint. arXiv:2610.13660

[133] Francois Chollet, Mike Knoop, Gregory Kamradt, Bryan Landers. ARC Prize 2024: Technical Report. 2024. arXiv preprint. arXiv:2412.04604

[134] Wallyson Lemes de Oliveira, Mekhron Bobokhonov, Matteo Caorsi, et al.. ARC-AGI-2 Technical Report. 2026. arXiv preprint. arXiv:2603.06590

[135] Jack Cole and Mohamed Osman. Don't throw the baby out with the bathwater: How and why deep learning for ARC. 2025. arXiv preprint. arXiv:2506.14276

[136] Caleb Talley, Vedant Tibrewal, Seun Adekunle, Weiwen Dong, Xinyu Wu, Fariha Sheikh. Multi-Perspective Transformers in ARC-AGI-2 Challenge. 2026. arXiv preprint. arXiv:2605.01154

[137] Adrien Deli`ege, Claas Beger, Marc Van Droogenbroeck, Melanie Mitchell. Implicit Rule Induction with Test-Time Task Embeddings in ARC-like Tasks. 2026. arXiv preprint. arXiv:2609.21181

[138] Matthew V Macfarlane, Clement Bonnet. Searching Latent Program Spaces. 2024. NeurIPS 2025. arXiv:2411.08706

[139] Matthew V. Macfarlane, Cl'ement Bonnet, Herke van Hoof, Levi H. S. Lelis. Gradient-Based Program Synthesis with Neurally Interpreted Languages. 2026. ICLR 2026. arXiv:2604.18907

[140] Zeyneb N. Kaya, Nick Rui. Test-Time Meta-Adaptation with Self-Synthesis. 2026. arXiv preprint. arXiv:2603.03524

[141] Chaehee Song, Minseok Seo, Yeeun Seong, Doyi Kim, Changick Kim. Query-Conditioned Test-Time Self-Training for Large Language Models. 2026. arXiv preprint. arXiv:2605.13369

[142] Haoyang He and Zihua Rong and Yunjia Zhao and Lan Yang and Jian Chang and Honggang Zhang. TTSR: Test-Time Self-Evolving via Reflection. 2026. arXiv preprint. arXiv:2603.03297

[143] Zhengbo Jiao, Hongyu Xian, Qinglong Wang, et al.. Policy of Thoughts: Scaling Test-Time Training for LLM Reasoning via Online Policy Evolution. 2026. arXiv preprint. arXiv:2601.20379

[144] Nikita Rajaneesh, Thomas Zollo, Richard Zemel. Test-Time Warmup for Multimodal Large Language Models. 2025. arXiv preprint. arXiv:2509.10641

[145] Jiahe Qian, Yuhao Shen, Zhangtianyi Chen, Juexiao Zhou, Peisong Wang. CoTBox-TTT: Grounding Medical VQA with Visual Chain-of-Thought Boxes During Test-time Training. 2025. arXiv preprint. arXiv:2511.12446

[146] Gege Zhang, Shuaicheng Niu, Gang Dai, Lei Sun, Shuangping Huang. Geometry-Aware Test-Time Learning for Quantitative Spatial Reasoning. 2026. arXiv preprint. arXiv:2609.06004

[147] Boyang Zhou, Johan Lindqvist, Lindsey Li. Reproducibility Report: Test-Time Training on Nearest Neighbors for Large Language Models. 2025. arXiv preprint. arXiv:2511.16691

[148] Jonas H"ubotter, Patrik Wolf, Alexander Shevchenko, Dennis J"uni, Andreas Krause, Gil Kur. Specialization after Generalization: Towards Understanding Test-Time Training in Foundation Models. 2025. ICLR 2026. arXiv:2509.24510

[149] Zixuan Wang, Xingyu Dang, Rui-Jie Zhu, et al.. Learning What to Remember: Test-Time Training via Context Distillation. 2026. arXiv preprint. arXiv:2608.01672

[150] Yue Wu, Yang Zhang, Weinan Gan, et al.. Select-TTT: Query-Conditioned Selective Fast Weight Updates for In-Place Test-Time Training. 2026. arXiv preprint. arXiv:2610.36794

[151] Yingfa Chen, Xingyu Shen, Chaojun Xiao, Xu Han. Latent Compaction with Test-Time Training. 2026. arXiv preprint. arXiv:2610.20582

[152] Junyi Zhu, Shuochen Liu, Yu Yu, et al.. FastMem: Fast Memorization of Prompt Improves Context Awareness of Large Language Models. 2024. EMNLP findings 2024. arXiv:2406.16069

[153] Dilxat Muhtar, Yelong Shen, Yaming Yang, et al.. StreamAdapter: Efficient Test Time Adaptation from Contextual Streams. 2024. arXiv preprint. arXiv:2411.09289

[154] Zekun Wang and Anant Gupta and Zihan Dong and Christopher J. MacLellan. Self-Consolidating Language Models: Continual Knowledge Incorporation from Context. 2026. arXiv preprint. arXiv:2605.07076

[155] Kiarash Zahirnia, Zahra Golpayegani, Walid Ahmed, Yang Liu. ETT: Expanding the Long Context Understanding Capability of LLMs at Test-Time. 2025. arXiv preprint. arXiv:2507.06313

[156] Xiaopeng Yuan, Zebin Wang, Suwen Wang, Zongxin Yang, Haohan Wang, Yushun Dong. EASE-TTT: Evidence-Aligned Selective Test-Time Training for Long-Context Question Answering. 2026. arXiv preprint. arXiv:2606.06906

[157] Xinyu Zhu, Zhe Xu, Xiaohan Wei, et al.. Self-Guided Test-Time Training for Long-Context LLMs. 2026. arXiv preprint. arXiv:2607.09415

[158] Bohao Wang, Xiaoyan Zhao, Yang Zhang, et al.. Using Context Is Not Enough: Test-Time Training for Personalized Reward Modeling. 2026. arXiv preprint. arXiv:2609.35109

[159] Sejun Park, Hyoungjo Bhang, Hyein Jeong, Yohan Jo. ProTTT: Learning to Learn Semantic User Memory with Test-Time Training. 2026. arXiv preprint. arXiv:2609.32564

[160] Yingzi Ma, Yulong Cao, Nanxi Li, et al.. HarnessTTT: Learn to Optimize Harness at Test-Time for Scientific Discovery. 2026. arXiv preprint. arXiv:2610.17370

[161] Tao Feng, Fangxu Yu, Zijie Lei, et al.. CURIO: Curiosity-Driven Test-Time Learning for Open-Ended Discovery. 2026. arXiv preprint. arXiv:2610.04851

[162] Chonghe Jiang, Ao Qu, Siyuan Liu, et al.. Evolving in Thought Space: Training a Small Model at Test Time Unlocks Better Discoveries. 2026. arXiv preprint. arXiv:2610.06269

[163] Gurusha Juneja, Arnav Kumar Jain, Deepak Nathani, William Yang Wang, Xin Eric Wang. Learning the ARTS of Search for Automated Discovery. 2026. arXiv preprint. arXiv:2606.21891

[164] Peilong Zhou, Zhirong Chen, Cangyuan Li, et al.. Alpha-RTL: Test-Time Training for RTL Hardware Optimization. 2026. arXiv preprint. arXiv:2606.05253

[165] Jia Liu, ChangYi He, YingQiao Lin, MingMin Yang, FeiYang Shen, ShaoGuo Liu. ETTRL: Balancing Exploration and Exploitation in LLM Test-Time Reinforcement Learning Via Entropy Mechanism. 2025. arXiv preprint. arXiv:2508.11356

[166] Hongxiang Lin and Zhirui Kuai and Erpeng Xue and Lei Wang. Detecting and Mitigating the Correct-Answer Extinction Window in Test-Time Reinforcement Learning with Majority Voting. 2026. arXiv preprint. arXiv:2605.19444

[167] Yongcan Yu, Lingxiao He, Jian Liang, et al.. Understanding and Mitigating Spurious Signal Amplification in Test-Time Reinforcement Learning for Math Reasoning. 2026. ACL findings 2026. arXiv:2604.21327

[168] Haoyu Zhang, Jiaxian Guo, Dong Yang, Yusuke Iwasawa, Yutaka Matsuo. AQA-TTRL: Self-Adaptation in Audio Question Answering with Test-Time Reinforcement Learning. 2025. Proceedings of Interspeech 2026, pp. 4603-4607. doi:10.21437/Interspeech.2026-288 arXiv:2510.05478

[169] Linghan Fang, Tianxin Xie and Li Liu. Boosting ASR Robustness via Test-Time Reinforcement Learning with Audio-Text Semantic Rewards. 2026. AAAI 2026. arXiv:2603.05231

[170] Yong Du, Yuchen Yan, Fei Tang, et al.. Test-Time Reinforcement Learning for GUI Grounding via Region Consistency. 2025. AAAI 2026. arXiv:2508.05615

[171] Huining Li, Yuxiang Duan, Jiyang Tan, et al.. Test-time Reinforcement Learning for Anomalous Video Understanding. 2026. arXiv preprint. arXiv:2609.26099

[172] Xikai Yang, Hieu Trung Nguyen, Dunyuan Xu, et al.. Noisy Test-Time Reinforcement Learning for Code LLMs. 2026. arXiv preprint. arXiv:2609.32172

[173] Jiajun Li, Yu Ding, Shisi Guan, Ran Hou, Wanyuan Wang. StarOR: Synergizing Tree Search and Test-Time Reinforcement Learning for Optimization Modeling. 2026. arXiv preprint. arXiv:2606.15197

[174] Peyman Hosseini, Ondrej Bohdal, Taha Ceritli, et al.. CG-TTRL: Context-Guided Test-Time Reinforcement Learning for On-Device Large Language Models. 2025. arXiv preprint. arXiv:2511.06430

[175] Jianghao Wu, Yasmeen George, Jin Ye, Yicheng Wu, Daniel F. Schmidt, Jianfei Cai. SPINE: Token-Selective Test-Time Reinforcement Learning with Entropy-Band Regularization. 2025. arXiv preprint. arXiv:2511.17938

[176] Bodong Du, Xuanqi Huang, Xiaomeng Li. Distribution-Aware Reward Estimation for Test-Time Reinforcement Learning. 2026. arXiv preprint. arXiv:2601.21804

[177] Ruotong Liao, Nikolai R"ohrich, Xiaohan Wang, et al.. Tool Verification for Test-Time Reinforcement Learning. 2026. arXiv preprint. arXiv:2603.02203

[178] Kunbin Xu, Xingzuo Li, Xuefeng Bai, Kehai Chen. Hi-TTRL: Regulating Consensus with Hints for Test-Time Reinforcement Learning. 2026. arXiv preprint. arXiv:2608.03545

[179] Ambuj Mehrish and Sebastiano Vascon. CoRE: Consensus Rewards via Equilibrium for Test-Time Reinforcement Learning. 2026. arXiv preprint. arXiv:2608.09324

[180] Dong Yan, Jian Liang, Yanbo Wang, Shuo Lu, Ran He, Tieniu Tan. What If Consensus Lies? Selective-Complementary Reinforcement Learning at Test Time. 2026. ACL 2026. arXiv:2603.19880

[181] Yi Li, Linan Yue, Weibo Gao. SelectTTRL: Representation-Guided Data Selection for Efficient Test-Time Reinforcement Learning. 2026. arXiv preprint. arXiv:2610.16104

[182] Zhixia Zhang, Binqian Xu, Huaiyang Wang, Yikun Ban, Dianbo Liu. MS-TTRL: Breaking the Frequency Conflict in Multiple-Solution Test-Time Reinforcement Learning. 2026. arXiv preprint. arXiv:2610.32234

[183] Chengyi Yang, Zhishang Xiang, Yunbo Tang, et al.. TTCS: Test-Time Curriculum Synthesis for Self-Evolving. 2026. arXiv preprint. arXiv:2601.22628

[184] Chengcao Yang. ANCORA: Learning to Question via Manifold-Anchored Self-Play for Verifiable Reasoning. 2026. arXiv preprint. arXiv:2604.27644

[185] Sikai Bai, Haoxi Li, Jie Zhang, Yongjiang Liu, Song Guo. TTVS: Boosting Self-Exploring Reinforcement Learning via Test-time Variational Synthesis. 2026. ACL findings 2026. arXiv:2604.08468

[186] Kun Wang, Reinhard Heckel. Test-time RL alignment exposes task familiarity artifacts in LLM benchmarks. 2026. arXiv preprint. arXiv:2603.12875

[187] Emre Can Acikgoz, Cheng Qian, Heng Ji, Dilek Hakkani-T"ur, Gokhan Tur. Self-Improving LLM Agents at Test-Time. 2025. arXiv preprint. arXiv:2510.07841

[188] Cheng Luo, Bing Li, Bernard Ghanem. Self-Generated Feedback Destabilizes Test-Time Training: A Causal Decomposition of Long-Horizon Adaptation. 2026. arXiv preprint. arXiv:2610.05076

[189] Shaoting Zhu, Baijun Ye, Jiaxuan Wang, et al.. TTT-Parkour: Rapid Test-Time Training for Perceptive Robot Parkour. 2026. arXiv preprint. arXiv:2602.02331

[190] Tianxin Wei, Noveen Sachdeva, Benjamin Coleman, et al.. Evo-Memory: Benchmarking LLM Agent Test-time Learning with Self-Evolving Memory. 2025. arXiv preprint. arXiv:2511.20857

[191] Jiayin Wang, Zhiquang Guo, Weizhi Ma, Min Zhang. How Far Can LLMs Improve from Experience? Measuring Test-Time Learning Ability in LLMs with Human Comparison. 2025. EMNLP 2025. arXiv:2506.14448

[192] Qingyao Ai, Yichen Tang, Changyue Wang, Jianming Long, Weihang Su, Yiqun Liu. MemoryBench: A Benchmark for Memory and Continual Learning in LLM Systems. 2025. arXiv preprint. arXiv:2510.17281

[193] Kangcong Li, Hangfan Zhang, Shuyue Hu, Shengji Tang, Tao Chen. ReTTT: Reflection-Driven Test-Time Training via Experience-Based Parametric Memory. 2026. arXiv preprint. arXiv:2610.23942

[194] Zhanzhi Lou, Hui Chen, Yibo Li, Qian Wang, Bryan Hooi. Meta-TTL: Meta-Learning Self-Improvement Policies for Language Agents. 2026. arXiv preprint. arXiv:2604.00830

[195] Jiahao Lu, Mohan Kankanhalli. Agentic-TTT: Training test-time policy for test-time training. 2026. arXiv preprint. arXiv:2610.12002

[196] Junxuan Li, Zijun Liu, Ziyi Huang, et al.. Learning Simple Test-Time Environments for LLM Web Agents. 2026. arXiv preprint. arXiv:2608.29305

[197] Prannay Hebbar, Yogendra Manawat, Samuel Verboomen, et al.. SIA: Self Improving AI with Harness & Weight Updates. 2026. arXiv preprint. arXiv:2605.27276

[198] Yishuo Cai, Xingyu Guo, Xuancheng Huang, et al.. From Player to Master: Enhancing Test-Time Learning of LLM Agents via Reinforcement Learning over Memory. 2026. arXiv preprint. arXiv:2606.08656

[199] Yunfan Jiang, Yevgen Chebotar, Ruijie Zheng, et al.. RoboTTT: Context Scaling for Robot Policies. 2026. arXiv preprint. arXiv:2607.15275

[200] Yize Liu, Huang Huang, Yining Hong, et al.. T2^2Mem: Learning Test-Time Memory for Robotics. 2026. arXiv preprint. arXiv:2609.36720

[201] Changyu Liu, Yiyang Liu, Taowen Wang, et al.. On-the-Fly VLA Adaptation via Test-Time Reinforcement Learning. 2026. ACL 2026. arXiv:2601.06748

[202] Siyao Chen, Jiakang Yuan, Jiaxin Wang, and Tao Chen. Trust Your Instincts: Confidence-Driven Test-Time RL for Vision-Language-Action Models. 2026. ECCV 2026. arXiv:2606.29892

[203] Hongjin Ji, Guoyang Xia, Luoyang Sun, Fangxiang Feng, Lei Ren. VANE: Reliable Test-Time Training for Vision-Language-Action Models via Future Visual Representation Prediction. 2026. arXiv preprint. arXiv:2608.09448

[204] Qiangong Zhou and Jiafeng Liang and Yimin Dong and Yang He and Hongxiang Li. TTT in VLA Models: Exploring Training with Human Demonstrations. 2026. arXiv preprint. arXiv:2610.32094

[205] Daehee Park, Jaeseok Jeong, Sung-Hoon Yoon, Jaewoo Jeong, and Kuk-Jin Yoon. T4P: Test-Time Training of Trajectory Prediction via Masked Autoencoder and Actor-specific Token Memory. 2024. CVPR 2024. arXiv:2403.10052

[206] Jude Waide, Robert Lieck. Decision Titan: Test-Time Training for Long-Term Memory in Offline Reinforcement Learning. 2026. arXiv preprint. arXiv:2610.01513

[207] Marco Bagatella, Mert Albaba, Jonas H"ubotter, Georg Martius, Andreas Krause. Test-time Offline Reinforcement Learning on Goal-related Experience. 2025. arXiv preprint. arXiv:2507.18809

[208] Yuhang Huang and Shilong Zou and Jiazhao Zhang and Xinwang Liu and Ruizhen Hu and Kai Xu. AdaPower: Specializing World Foundation Models for Predictive Manipulation. 2025. arXiv preprint. arXiv:2512.03538

[209] Chi Wan and Kangrui Wang and Yuan Si and Pingyue Zhang and Manling Li. WorldAgen: Unified State-Action Prediction with Test-Time World Model Training. 2026. AAAI 2026. arXiv:2609.08162

[210] Krishnam Soni, Aditya Sehgal, Vedant Dave, and Elmar Rueckert. Sandwich-Residuals: Parameter-Efficient Test-time Adaptation of World Models. 2026. arXiv preprint. arXiv:2609.21740

[211] Yusen Feng, Bingchen Han, Jiangran Lyu, et al.. WAM-TTT: Steering World-Action Models by Watching Human Play at Test Time. 2026. arXiv preprint. arXiv:2607.06988

[212] Junchen Liu, Sven Elflein, Or Litany, Zan Gojcic and Ruilong Li. Test-Time Training with KV Binding Is Secretly Linear Attention. 2026. arXiv preprint. arXiv:2602.21204

[213] Yuhe Hu. Error Correction in Trained TTT Layers. 2026. arXiv preprint. arXiv:2610.16268

[214] Halil Alperen Gozeten, M. Emrullah Ildiz, Xuechen Zhang, Mahdi Soltanolkotabi, Marco Mondelli, Samet Oymak. Test-Time Training Provably Improves Transformers as In-context Learners. 2025. ICML 2025. arXiv:2503.11842

[215] Simone Antonelli, Sadegh Akhondzadeh, Aleksandar Bojchevski. Test-Time Training Undermines Safety Guardrails. 2026. arXiv preprint. arXiv:2605.22984

[216] Tianshuo Cong and Xinlei He and Yun Shen and Yang Zhang. Test-Time Poisoning Attacks Against Test-Time Adaptation Models. 2023. IEEE S&P 2024. arXiv:2308.08505

[217] Vanshaj Khattar, Md Rafi ur Rashid, Moumita Choudhury, et al.. Amplification Effects in Test-Time Reinforcement Learning: Safety and Reasoning Vulnerabilities. 2026. arXiv preprint. arXiv:2603.15417

[218] Kento Kuwataka, Taiji Suzuki. Test time training enhances in-context learning of nonlinear functions. 2025. arXiv preprint. arXiv:2509.25741

[219] Tomoya Wakayama. A Decision-Theoretic View of Test-Time Training: When, How Far, and Which Directions to Adapt. 2026. Proceedings of Machine Learning Research, 306:124279-124317, 2026 (ICML 2026). arXiv:2606.15569

[220] Tongyan Hu, Hao Li, Xiaogeng Liu, et al.. Red-TTT: Test-Time Training for Automated Jailbreaking Large Language Models. 2026. arXiv preprint. arXiv:2610.05282

[221] Morgan Thomas, Albert Bou, Gianni De Fabritiis. Test-Time Training Scaling Laws for Chemical Exploration in Drug Design. 2025. J. Chem. Inf. Model. 2025. arXiv:2501.19153

[222] Tobit Klug and Kun Wang and Stefan Ruschke and Reinhard Heckel. MotionTTT: 2D Test-Time-Training Motion Estimation for 3D Motion Corrected MRI. 2024. NeurIPS 2024. arXiv:2409.09370

[223] Zhiwen Yang, Jiayin Li, Hao Lu, Hui Zhang, Zihua Wang, Yan Xu. U-TTT: Towards Generalizable PET Image Denoising via Test-Time Training. 2026. arXiv preprint. arXiv:2606.11032

[224] Mingzhi Chen, Yiyu Gui, Guibo Luo. MedTS-TTT: Test-Time Training for Medical Time Series Classification. 2026. MICCAI 2026. arXiv:2606.21329

[225] Avishkar Behera, Riya Ann Easow, Venkatesh Parvathala, K. Sri Rama Murty. Test-Time Training for Speech Enhancement. 2025. Proceedings of Interspeech 2025, pp. 2375-2379. doi:10.21437/Interspeech.2025-2725 arXiv:2508.01847

[226] Taewoo Kim, Uijong Lee, Hayoung Park, Choongsang Cho, Nam In Park, Young Han Lee. Instance-Specific Test-Time Training for Speech Editing in the Wild. 2025. arXiv preprint. arXiv:2506.13295

[227] Panayiotis Christou, Shichu Chen, Xupeng Chen, Parijat Dube. Test Time Learning for Time Series Forecasting. 2024. arXiv preprint. arXiv:2409.14012

[228] Xin Di, Xinglin Piao, Fei Wang, Guodong Jing and Yong Zhang. REE-TTT: Highly Adaptive Radar Echo Extrapolation Based on Test-Time Training. 2026. arXiv preprint. arXiv:2601.01605

[229] Zhaoqi Yang, Yanan Wang, and Yong Ge. TTT4Rec: A Test-Time Training Approach for Rapid Adaption in Sequential Recommendation. 2024. arXiv preprint. arXiv:2409.19142

[230] Xihong Yang, Yiqi Wang, Jin Chen, et al.. Dual Test-time Training for Out-of-distribution Recommender System. 2024. IEEE TKDE 2025. arXiv:2407.15620

[231] Panteleimon Dogoulis, Mohammad Iman Alizadeh, Sylvain Kubler, Maxime Cordy. Test Time Training for AC Power Flow Surrogates via Physics and Operational Constraint Refinement. 2025. arXiv preprint. arXiv:2511.22343

[232] Felix Teufel, Aaron W. Kollasch, Yining Huang, et al.. Few-shot Protein Fitness Prediction via In-context Learning and Test-time Training. 2025. arXiv preprint. arXiv:2512.02315

[233] Wentao Zhu and Yufang Huang and Daguang Xu and Zhen Qian and Wei Fan and Xiaohui Xie. Test-Time Training for Deformable Multi-Scale Image Registration. 2021. ICRA 2021. arXiv:2103.13578

[234] Qikang Zhang, Yingjie Lei, Zihao Zheng, Ziyang Chen, Zhonghao Xie. Test Time Training for 4D Medical Image Interpolation. 2025. IJCNN 2025. arXiv:2502.02341

[235] Qinhua Xie, Hao Tang. TTTFusion: A Test-Time Training-Based Strategy for Multimodal Medical Image Fusion in Surgical Robots. 2025. IROS 2025. arXiv:2504.20362

[236] Yi Luo, Yike Guo, Wenxuan Li, Zongwei Zhou, Rui Zhang, and Kai Ding. LeCor: Learning to Be Corrected by Meta-Learned Test-Time Training for Interactive 3D Lung-Tumour Segmentation. 2026. arXiv preprint. arXiv:2609.09477

[237] Suli Wang, Yangshen Deng, Zhenghua Bao, Xinyu Zhan, Yiqun Duan. NeuroTTT: Bridging Pretraining-Downstream Task Misalignment in EEG Foundation Models via Test-Time Training. 2025. arXiv preprint. arXiv:2509.26301

[238] Xiaolei Lu, Shamim Nemati. Adaptive Test-Time Training for Predicting Need for Invasive Mechanical Ventilation in Multi-Center Cohorts. 2025. ICLR 2026. arXiv:2512.06652

[239] Rong Zhou, Zhengqing Yuan, Zhiling Yan, et al.. TTT-Unet: Enhancing U-Net with Test-Time Training Layers for Biomedical Image Segmentation. 2024. arXiv preprint. arXiv:2409.11299

[240] Yehoshua Dissen and Joseph Keshet. Self-Supervised Test-Time Tuning for Packet Loss Concealment. 2026. arXiv preprint. arXiv:2607.01823

[241] Daniel Chen, Qicong Hu, Yang Xiao, Ting Dang, Hong Jia. Titans-as-a-Layer: Test-Time Memory for Conversational Speech Emotion Recognition. 2026. arXiv preprint. arXiv:2606.08573

[242] Sercan O. Arik, Nathanael C. Yoder and Tomas Pfister. Self-Adaptive Forecasting for Improved Deep Learning on Non-Stationary Time-Series. 2022. arXiv preprint. arXiv:2202.02403

[243] Mohamed Readh Fentazi, Mazene Ameur and Adlen Ksentini. Training on the Future: A Delay-Aware Audit of Test-Time Adaptation for Time-Series Forecasting. 2026. arXiv preprint. arXiv:2610.12232

[244] Delaram Pirhayati, Arlei Silva. Cross-Domain Graph Anomaly Detection via Test-Time Training with Homophily-Guided Self-Supervision. 2025. Pirhayatifard, D. and Silva, A. (2025). Cross-Domain Graph Anomaly Detection via Test-Time Training with Homophily-Guided Self-Supervision. Transactions on Machine Learning Research (TMLR). https://openreview.net/forum?id=sB3LqdOlNb. arXiv:2502.14293

[245] Yuehang Si and Zefan Zeng and Jincai Huang and Qing Cheng. T3DM: Test-Time Training-Guided Distribution Shift Modelling for Temporal Knowledge Graph Reasoning. 2025. arXiv preprint. arXiv:2507.01597

[246] Jiaxin Zhang, Yiqi Wang, Xihong Yang, et al.. Test-Time Training on Graphs with Large Language Models (LLMs). 2024. ACM MM 2024. arXiv:2404.13571

[247] Wenting Zhu, Chaozhuo Li, Qingpo Yang, Xi Zhang and Philip S. Yu. T3MAL: Test-Time Fast Adaptation for Robust Multi-Scale Information Diffusion Prediction. 2025. arXiv preprint. arXiv:2507.12880

[248] Liyuan Zhang, Zeyun Cheng, Yan Yang, Yong Liu, Jinke Ma. T3^\text{3}SVFND: Towards an Evolving Fake News Detector for Emergencies with Test-time Training on Short Video Platforms. 2025. DASFAA 2025. arXiv:2507.20286

[249] Changshuo Zhang, Xiao Zhang, Teng Shi, Jun Xu, Ji-Rong Wen. Test-Time Alignment for Tracking User Interest Shifts in Sequential Recommendation. 2025. arXiv preprint. arXiv:2504.01489

[250] Tianyu Zhan, Zheqi Lv, Shengyu Zhang, Jiwei Li. Preliminary Evaluation of the Test-Time Training Layers in Recommendation System (Student Abstract). 2024. AAAI 2025. doi:10.1609/aaai.v39i28.35323 arXiv:2411.15186

[251] Tobias Kreiman and Aditi S. Krishnapriyan. Understanding and Mitigating Distribution Shifts For Machine Learning Force Fields. 2025. arXiv preprint. doi:10.1039/d5dd00260e arXiv:2503.08674

[252] Yunhua Zhong, Runting Li, Yifan Li, et al.. Transferable Mass Spectrum Prediction via Reference-Guided Test-time Specialization. 2026. arXiv preprint. arXiv:2609.35649

[253] Yuyuan Feng, Guosheng Hu, Xiaodong Li, Zhihong Zhang. Adapting Amidst Degradation: Cross Domain Li-ion Battery Health Estimation via Physics-Guided Test-Time Training. 2024. arXiv preprint. arXiv:2402.00068

[254] Anran Xu and Lindsey J. Heagy. A Test-Time Learning Approach to Reparameterize the Geophysical Inverse Problem with a Convolutional Neural Network. 2023. IEEE Trans. Geosci. Remote. Sens. 2024. doi:10.1109/TGRS.2024.3424659 arXiv:2312.04752

[255] Lucia Gordon, Serge Belongie, Christian Igel, Nico Lang. MMEarth-Bench: Global Model Adaptation via Multimodal Test-Time Training. 2026. ECCV 2026. arXiv:2602.06285

[256] Damien Jian, Yu-Chao Huang, Hsi-Sheng Goan. Test-Time Training with Quantum Auto-Encoder: From Distribution Shift to Noisy Quantum Circuits. 2024. arXiv preprint. arXiv:2411.06828

Cite this report

bibtex
@misc{parallax-2026-test-time-training-survey, title = {{Test-Time Training: A Survey of Learning at Inference, from Self-Supervision to Memory Layers, LLMs and Agents}}, author = {{Parallax}}, year = {2026}, month = nov, howpublished = {\url{https://parallax.ink/research/en/test-time-training-survey}}, url = {https://parallax.ink/research/en/test-time-training-survey}, note = {Parallax Research, Survey} }

Keep reading