Today we want to start from a quick analysis of OpenAI’s Navier–Stokes experiment that can give you more insights about inference, or test-time, stage that you can imagine. First of all, it gives us a picture of what happens when models are allowed to do much more work at inference.

The chart compares GPT‑6 Astra with OpenAI’s next-generation internal model on a set of open math problems. Two things are happening at once. The new model starts from a much higher level, and additional test-time compute keeps pushing both models further. Part of the leap comes from training a stronger model, but another part comes from giving it more time, attempts, and compute after it receives the problem. In the Navier–Stokes run, around 10,000 agents spent 88 hours exploring different approaches, sharing useful findings, and improving performance through context, coordination, tools, and test-time compute.

But more globally, there is a larger shift in inference – it has stopped being one fixed model producing one answer. Current studies have turned it into an active process that can continue for hours and improve its route to the solution. But we are mostly improving the process around the model. What about the model’s evolution during inference?

When we explored test-time compute and test-time scaling to write an article about it (that was more than a year ago!), we saw that one of the potential directions for improving a model’s reasoning during inference was test-time training (TTT). We haven’t seen a boom in test-time training yet, but we’re at an interesting point where researchers are starting to explore it and what it can do.

While test-time compute means using more computation during inference while keeping the model’s weights fixed, test-time training means the model continues adapting or updating itself during the test phase. TTT challenges the traditional idea that learning ends when a model is deployed.

Here, the line between training and inference begins to blur. TTT moves toward systems that can adjust to new conditions while they are being used, which is especially useful when data changes rapidly. And that’s why it can bring great benefits to world models, which are all about fast adaptation to new states, actions and environment.

Today, we will unpack what test-time training is, how it works, where it is already used, and how it upgrades world models’ capabilities in real-world tasks. Let’s go! It will be interesting.

In today’s episode:

The essential definitions

Before we move on to the core explanation of test-time training, we need to check all the definitions that will help us understand it (if you already know them, you can skip this section).

TTT is one way to do test-time adaptation through parameter updates and self-supervised learning. Now let’s see how this happens in general.

What is Test-Time Training?

The main basics of test-training (TTT) were explained in the 2020’s paper by Yu Sun and other researchers from University of California, Berkeley. It is called “Test-Time Training with Self-Supervision for Generalization under Distribution Shifts”, and it describes TTT as a broad approach in which a model adapts while it is being used.

TTT follows the core idea that inference does not have to be passive. Training can continue during inference to improve a model’s performance on completely new data that it meets while operating in the real world.

How Test-Time Training works

TTT begins after a model has already been trained and deployed. Its goal is to let the model adjust to the data currently in front of it. Imagine new data now arrives from the environment where the model is being used, for example, an image uploaded by a user, a frame from a robot’s camera, or a piece of recorded speech.

The model needs to make a prediction about this new input, which is its main task. But it doesn’t know the correct answer and so can’t learn from like it learned from a normal labeled training task. The model needs to take a different route here, and TTT helps it do that. The entire process looks like this:

Note that the model doesn’t learn the object’s true label from the test example, it just uses a related task to better understand the data before making its prediction.

This process will become clearer with an example from the original Yu Sun’s paper:

There, the main task was image classification, and the self-supervised task was rotation prediction. Before classifying a new image, the system rotated it by 0°, 90°, 180°, or 270° and asked the model to identify the angle. If the system rotates that image by 90°, it knows that the correct rotation label is 90°. And since the system applies the rotation itself, it already knows the correct answer and doesn’t need a human-provided label.

The model uses its mistakes on this auxiliary task to update its shared visual features. These features are also used for object recognition, so adapting them to the new image could improve the final classification.

TTT can work in several ways:

It is crucial to keep this in mind: A test example also contains information about the environment the model is currently operating in. TTT uses that information to make the model better suited to the data in front of it.

Although the original work is focused on image recognition, TTT has already been extended to segmentation, computer vision, time series, speech, restoring noisy audio, graphs, language, robotics, world models and many other areas. Now let us explore some advanced examples (including agentic and world models TTT!).

Studies That Marks Test-Time Training as an Emerging Trend