At the beginning of the year, we dove into one of the main concepts that became central to taking models to the next level of reasoning. Yes, it’s test-time compute and its scaling. That article was one of the most popular, showing huge interest in what’s happening at the inference stage of AI models.
Test-time compute is the key to influencing a model's behavior after the training stage – during inference, when it shows all its gained capabilities. But scaling test-time compute can unlock even more from models. This strategy also came with the rise of Language Reasoning Models (LRMs), which are the spotlight together with agents.
A lot happened since the beginning of the year in test-time compute research – from new strategies for smarter scaling to studies revealing its limits and occasional drawbacks. It’s still a bit of a messy topic, but its role is hard to overstate. Test-time compute sits at the heart of shaping a model’s real-world performance, and the discussions around it echo what’s happening in many parts of AI – from multimodal systems and world models to agents and reasoning models’ behavior.
Today we’re going to look at three of the latest outstanding approaches to test-time compute scaling:
Chain-of-Layers (CoLa) – a method that allows for better control and optimization of reasoning models.
Blending Vision-Language Models (VLMs) and world models with the MindJourney test-time scaling framework.
Applying the diffusion process for test-time scaling to build a better deep research agent – Google Cloud’s TTD-DR.
We will also look at the opposite of the test-time scaling strategy to see what can go wrong and be better aware of the bad effects.
So, let’s investigate the true side of test-time compute scaling – now more proven over time.
In today’s episode, we will cover:
A quick reminder about test-time compute and its scaling
Controllable test-time compute
Chain-of-Layers (CoLa) method
How CoLa actually influences the performance
World models, VLMs and test-time scaling
How does MindJourney work?
Results of MindJourney
Strengths and limitations
Google Cloud’s Test-Time Diffusion Deep Researcher (TTD-DR)
TTD-DR workflow
Why TTD-DR is better than other Researchers
Benefits and issues
Where test-time scaling falls short: 5 key failures
Conclusion
Sources and further reading
What Is Test-Time Scaling? A Quick Refresher
Test-time compute (TTC) is the processing power an AI model uses when generating responses after training. In other words, it’s the compute cost of using the model during the inference stage. This includes all the operations the model performs, such as passing inputs through its layers, reasoning step-by-step, and generating outputs.
Test-time scaling is the strategy of using more compute at inference time. This can mean increasing the number of reasoning steps by implementing Chain-of-Thought (CoT) reasoning, using larger context windows, running multiple model passes and aggregating results, etc. This approach prioritizes slower reflective “thinking” over fast responses.
The main idea behind this is that performance can improve without retraining, because the model “works harder” on each task. Here is what the most up-to-date approaches can offer to apply this scaling strategy more smartly and effectively to various models and agents.
Let’s start with how we can actually control the reasoning length in models.
Controllable test-time compute
Test-time scaling usually means increasing compute, like deeper models, more layers, multiple forward passes at inference time to improve performance. But as this paradigm was used more, many started to follow the principle: Why always use more compute budget if some tasks are better performed without explicit “thinking”? Many advanced reasoning and agentic models – Claude 4, Qwen3, GLM-4.5, already include the feature of switching between fast responses and extended step-by-step thinking.
Following this shift, a recent paper from the Department of Computer Science, University of Maryland proposes its own point of view on dynamic and adaptive “thinking”. Instead of using the full model in a fixed way for every input, it explores how to adjust the model's depth and layer composition per input, at test time.
The approach selectively uses more compute (for example, repeating layers for harder problems) or less compute, like skipping layers for easier ones, which they call test-time depth adaptation. To make this real they propose a Chain-of-Layer (CoLa) method. It’s like a challenge to naive test-time scaling, because it shows you can often do better with less, if you're smart about layer use. So let’s dive into how it works.
Chain-of-Layers (CoLa) method
The main idea behind the research from University of Maryland is to make a pretrained model smarter at test time by customizing which layers it uses without any retraining. So the researchers treat the layers of the model like building blocks that can be rearranged. For each test example, they build a custom version of the model using those blocks. This flexible way of building a model for each input is called CoLa (Chain-of-Layers). It allows to:
Skip layers for faster, simpler tasks
Recurrently reuse them to simulate deeper thinking, like an RNN
Reorder layers to find more useful compositions
To figure out the best custom layout of layers for each input, they use a Monte Carlo Tree Search (MCTS) method – one of the most popular search methods often used in different test-time compute optimization approaches and in game AI (like AlphaGo). The main advantage of MCTS is that it balances exploration (trying new ideas) and exploitation (using what’s already working).
Image Credit: CoLa original paper
Well, in the CoLA approach, MCTS tries out different layer paths and searches a path that makes accurate predictions with as few layers as needed. Here is how it works:
Each state represents a partial or complete layer sequence. The starting point is just the original path.
Actions can change that sequence. They can be like “Skip k layers”, “Repeat k layers r times”, where k and r range from 1 to 4.
Image Credit: CoLa original paper
Once a path is built, the model runs it on the input and produces an output. If the output is correct, it gets a reward of 1, minus a penalty for using too many layers to encourage efficiency.
UCB (Upper Confidence Bound) is used as a scoring function to pick the next paths to explore, which:
encourages paths with good past performance (exploitation),
explores less-visited paths (exploration),
penalizes long layer paths to favor shorter, efficient models.
Once the search is done, the algorithm picks a Pareto-optimal set - solutions that offer the best accuracy vs. efficiency trade-off. The final result is a constructed custom Chain-of-Layers (CoLa).
During these stages no model parameters are changed – CoLa just uses the pretrained layers more intelligently.
How CoLa actually influences the performance
As seen from the experiment results, this dynamic skipping or repeating of layers at test time via CoLa consistently outperforms using a fixed sequence. Skipping, looping, and rearranging layers guided by MCTS lets us unlock more performance already hidden inside the model. For example:
Skip-only helps with simple tasks, reducing depth and computation.
Recurrence-only helps the model think more deeply and get better results in harder tasks.
Together, they adapt the model depth to input difficulty and achieve up to 3× accuracy gains on hard tasks without training.
Image Credit: CoLa original paper
Other important takeaways include:
Effective rethinking of models’ configurations: CoLa often finds shorter paths that still produce correct predictions (for over 75% of cases).
Notably, correcting a wrong answer also often needs fewer layers, not more. For more than 60% of wrong answers, a better layer arrangement actually fixed the mistake.
There is the difference in large and small models functioning:
Harder tasks and larger models use layers more uniformly. Larger models, for example, with 8B parameters, also adapt more dynamically.
Smaller models show stronger pruning in the middle layers. Smaller models rely on fixed patterns, like always skipping certain layers.
CoLa worked good across math and commonsense reasoning benchmarks and on both regular and instruction-tuned models.
However, some issues remain in CoLa approach:
MCTS is computationally expensive. It can be costly and slow at inference time, especially for real-time or large-scale deployment, involving executing the model multiple times.
There is no guarantee CoLa finds the globally optimal execution path.
The method is evaluated on models up to LLaMA-3 8B and on moderate-length reasoning tasks, but it is unclear how well it scales to models with more layers, let’s say, 70B+, or to very long contexts.
While CoLa changes layer order, it does not combine outputs across layers or perform more complex re-routing.
There is no information on how good it is at vision, dialogue, or multi-modal tasks yet.
Overall, CoLa proposes a new interesting way to generalize at test time through test-time architectural adaptation. It also proves that fixed LLM architectures might be limiting. The key moment here is that retrained layers can act like modular reasoning tools, not just a fixed pipeline. When models dynamically adjust which layers are used and how, they can become faster, more efficient, and even more accurate without any additional training.
Another amazing evolving field in AI is related to teaching models to understand the real world better. Basically, there are world models that simulate how this world works and learn to predict what happens next in an environment based on actions or changes in viewpoint. What if we incorporate the concept of test-time scaling into this kind of models?
World models, VLMs and test-time scaling
Researchers from UMass Amherst, Microsoft Research, JHU, HKUST, and Harvard in their recent research “Test-Time Scaling with World Models for Spatial Reasoning” promoted the following idea: Adding 3D understanding capabilities, or spatial intelligence, to 2D understanding at test-time. This ended in a special MindJourney test-time framework.
How does MindJourney work?
At its core, MindJourney pairs a Vision Language Model (VLM) with a video-based world model:
The VLM handles high-level reasoning and language understanding, but it only “sees” the image in 2D and struggles with 3D reasoning.
The world model handles 3D visual simulation, allowing the model to reason more like humans by simulating how a scene looks from different angles.
The mission of MindJourney is to help existing VLMs get better at 3D spatial reasoning without retraining them. MindJourney can be added to existing VLM without retraining. This collaboration makes the overall system much better at tasks that need an understanding of 3D space.
Here’s how MindJourney step-by-step pipeline works:
Image Credit: MindJourney pipeline, MindJourney original paper
Input: You provide a spatial question, like “What would be behind the object if you turn right?”, and one image.
Step-by-step search:
A VLM, called the Search VLM, proposes a short movement, for example, “move forward 0.2m, turn left 30°”, “turn left” or “walk forward”.
The World Model, based on video diffusion, is given one image and this planned camera movement. It generates a short, imagined video frame of how the scene would look from that new perspective – an image or video frame from this new viewpoint. This turns a static 2D image into a virtual 3D environment the model can explore.
Then the system steps into the Spatial Beam Search (planning loop) stage. At each step of the search, the VLM analyses all the current movement paths it has considered so far, called the “beam”. Each beam node is expanded by trying new trajectories (added sequences of more small actions).
For every trajectory in the current beam node, The World Model creates views.
Image Credit: MindJourney original paper
The VLM evaluates how useful each new view is, considering 2 criteria:
“How useful is it to keep exploring this trajectory?”
“How useful is this view for answering now?”
This continues for a few steps, building a map of helpful viewpoints.
Final answer: After collecting helpful views, a Question-Answering VLM takes the original image + the helpful imagined views and gives a final answer.
The main thing here is that all this happens at test-time! The loop “imagine → select → answer” gives MindJourney its power, even though the VLM itself is frozen. This framework lets VLMs explore new viewpoints virtually, just like a person would mentally visualize turning or walking in a space. But how effective is this test-time scaling approach for VLMs, really?
Results of MindJourney
MindJourney was tested on the SAT benchmark, which includes a range of 3D spatial reasoning tasks. The results were impressive:
It improved performance by an average of 8.1%, with some tasks seeing up to 15% improvement.
MindJourney improved accuracy on all five spatial reasoning types, including egocentric motion, object motion, action consequences, perspective shifts, goal-directed navigation.
Image Credit: MindJourney original paper
It worked well with different VLM backbones and two types of diffusion-based world models: SWM (Search World Model, their custom one) and publicly available SVC (Stable Virtual Camera) – a state-of-the-art video diffusion model.
It even outperformed models trained with reinforcement learning, like o1.
Strengths and limitations
Here are all the advantages of MindJourney:
This “plug-and-play” approach is both simple and powerful.
It works even without retraining the VLM.
It can power any existing VLM.
MindJourney can also enhance RL-trained models like o1 further, because giving a model access to an imagined 3D environment helps it reason better, even beyond what RL alone can do.
However, the important limitation is that MindJourney’s effectiveness relies on the quality of the world model:
When the imagined 3D path drifts too far from the input image, generation quality degrades.
The noisy visual evidence can hurt VLM decision-making.
Longer roll-outs will require better video generation models with strong geometric consistency.
MindJourney is the perfect example of how test-time scaling can dramatically boost performance of VLMs, especially when paired with the powerful tools like controllable video-based World Models. This is a great shift in how test-time scaling extends models’ capabilities from 2D to 3D.
In MindJourney, researchers used diffusion-based world models. But there’s something even more interesting in the way test-time scaling and diffusion work together – both are closely tied to the refinement process. That’s why we couldn’t skip Google’s recent Deep Researcher, which dives deeper into this idea.
Google Cloud’s Test-Time Diffusion Deep Researcher
Test-Time Diffusion Deep Researcher (TTD-DR) is a test-time framework that treats long-form research report generation as an iterative refinement process. It doesn’t create everything at once, it works in a loop more similar to how humans do a research: draft → search → revise → repeat.
TTD-DR uses additional computation exactly at inference time to gradually improve outputs. Let’s look at how it works more precisely →
TTD-DR workflow
TTD-DR basically treats research writing as a denoising process, following the steps below:
Image Credit: TTD-DR original paper
Planning the structure of the report: A dedicated LLM agent creates a structured research plan based on the user’s query, which outlines what needs to be answered, giving direction to the next stages.
The agent generates a search question using the original query, the research plan, and previous context.
It drafts a noisy, rough initial version of the report using the LLM’s current knowledge.
TTD-DR searches for information based on the draft and the plan.
Denoising the draft step-by-step: The agent refines the draft using new information from external sources via search and retrieval.
It repeats this loop “search → update → refine → repeat” several times. After collecting all question–answer pairs and the plan, the agent writes the final, coherent report.
TTD-DR uses a self-evolution system to improve each of the above stages.
As we’ve already mentioned everything happens at test time, so you don’t need extra training for TTD-DR. There are two main components that make TTD-DR adaptable and allow for self-reflection:
Denoising with retrieval
This feature helps to perform report-level denoising. After generating the initial draft, at each step TTD-DR generates a new search question based on what’s missing in the report. It searches and retrieves for relevant documents online or in a knowledge base, creates an answer and uses this new information to refine the draft, adding new insights or fixing errors. This loop continues for several rounds until TTD-DR finally has a complete “denoised” report. So TTD-DR updates the draft along the way, letting it adapt to new information as it's discovered.
Image Credit: TTD-DR original paper
2. Component-wise self-evolution
The second component refines and independently optimizes each step of the agent’s workflow, like planning, questioning, answering, writing. And here’s how:
Image Credit: Component-wise self-evolution, TTD-DR original paper
It generates multiple variants of an output, like multiple answers to a question.
Scores and critiques each using a judging model or auto-rater. It evaluates helpfulness, relevance, accuracy, etc.
Then, the agent revises each variant based on feedback.
Finally, it merges the best parts into a final version.
This self-evolution process happens within each component, making every part of the system smarter and more reliable over time. It helps to avoid information loss over long multi-hop reasoning chains and leads to better final reports.
These two processes, draft refinement and component-wise self-improvement, work together to strengthen the agent’s performance at all levels at reasoning simultaneously.
Why TTD-DR is better than other Researchers
As for the performance results, TTD-DR outperforms existing Deep Research agents:
On long-form research tasks, it beats OpenAI Deep Research, Grok and Perplexity Deep Research agents, Gemini-2.5 with:
69.1% win rate on the LongForm Research dataset
74.5% win rate on the DeepConsult dataset
Image Credit: TTD-DR original paper
On short-answer benchmarks (like HLE-Search, HLE-Full, GAIA), it also shows measurable gains, like improvements in correctness over OpenAI Deep Research and Gemini-2.5 models.
Image Credit: TTD-DR original paper
In summary, TTD-DR offers the following advantages →
Benefits and issues
Here are the advantages:
It mimics how humans write: not in one go, but through planning, feedback, and revision. It has a global writing process, instead of splitting the task into isolated sections.
An evolving draft maintains coherence: TTD-DR integrates new retrieved information on the fly at every step, unlike systems that only search at the start and lack a real feedback loop. This keeps the writing accurate and contextually rich.
TTD-DR is modular and upgradeable: Each step, like planning, answering, writing, can improve independently using self-evolution.
Self-evolution also encourages diverse search questions and answers.
It achieves significant performance gains without relying on extra tools like web browsers or multimodal inputs, it’s just standard LLM + search.
Better performance per unit of compute (latency): The trade-off between quality and latency is favorable – even with longer processing, the performance gains are more significant.
It works fully at test-time, no need for model fine-tuning.
But are there any limitations? Unfortunately, yes.
Tool use: Relying on search tools only is considered as advantage, but actually, TTD-DR doesn’t yet support other useful tools such as web browsing and coding tools.
As TTD-DR only uses test-time strategies, it doesn’t fine-tune or adapt to specific tasks or domains.
These three studies that we have explored show different test-time scaling strategies that that lead to significant performance and constructional gains, giving a snapshot of what is happening in AI right now. However, test-time scaling is not a perfect solution for every task. Another important study explored those cases where test-time scaling strategies have the opposite effect →
Where test-time scaling falls short
Well, what we’ve got in the middle of the 2025 is that longer reasoning doesn’t actually always help, as in some cases it reinforces bad reasoning patterns instead of fixing them. This is what researchers from Anthropic, Constellation, Scale AI, and University of Edinburgh found in their recent “Inverse Scaling in Test-Time Compute” research. They identified the cases of inverse scaling when with more reasoning lengths accuracy goes down.
What went wrong: 5 key failures
More reasoning leads to more distraction. Models tend to treat irrelevant info as important when thinking too long, trying to use all context from the prompt. For example, giving models an easy question: “You have an apple and an orange. How many fruits?” with hidden irrelevant details in the middle, like random code snippets, probabilities or equations, distracted even Claude Opus 4 and DeepSeek-R1 as reasoning got longer. OpenAI models, like o3, resisted distractions but became rigid, overfitting to the exact phrasing of the problem.
Familiar-looking problems trigger memorized solutions even when that’s not what’s being asked.
Zero-shot and few-shot matter: In zero-shot settings without guidance, more “thinking” drifts models toward wrong but plausible correlations. Few-shot (just 8–16 examples) helps keep models focused on the right features.
All models struggle more in natural “thinking” mode when they “decide” on their own how much reasoning to do. They explore too many paths, even inconsistent and chaotic, wasting budget. This was proven in tests with Zebra Puzzles, where only in rare cases, like with Claude Opus 4 and OpenAI o3 on the hardest 8×8 puzzles, did the extra thinking lead to better answers.
Safety issues: As reasoning length increases, the share of “safe” responses of Claude Sonnet 4 fell from 60% to 47%. DeepSeek-R1 stayed stable and OpenAI o3 showed a slight positive trend from 72% to 76%. So we need to pay more attention to potential safety issues too.
These conclusions show that all models sometimes replace good reasoning with wrong correlations, as test-time compute scales. They also struggled to stay focused on complex logic problems over multiple steps. So in parallel with increasing the effectiveness of test-time scaling strategies, there is a mission to test models not just at one reasoning depth, but across multiple lengths, to catch and understand these hidden weaknesses.
Conclusion
Of course, this is not the end of the test-time scaling story. We are not even in the middle of it. But what we know for sure is that applying the test-time scaling paradigm to different AI concepts and models remains a great way to unlock a wider range of a models’ possibilities. Google Cloud’s TTD-DR is a form of test-time scaling + agents + diffusion, and MindJourney smartly blends VLMs and world models for the sake of a better future of spatial intelligence. But after all, current studies encourage us to stay cautious and not overhype test-time scaling. Chain-of-Layers stands for the control of computing budget, with inverse scaling breathing down our neck, reminding us that there’s still so much left to explore. And the work continues.
Sources and further reading
Resources from Turing Post
