Databricks has released Adaptive Instructed-Retriever, a search model that intelligently decides how much computation each query needs, achieving frontier-level accuracy while responding 2x faster than competing systems. The breakthrough combines parallel single-step retrieval with sequential multi-step search, using reinforcement learning to spend extra computational effort only when it actually improves results.

What Is Test-Time Compute and Why Does It Matter for Search?

Test-time compute refers to the computational resources a model uses during inference, or when it's actually answering a question, rather than during training. Traditionally, AI models use a fixed amount of computation for every query. Adaptive Instructed-Retriever changes this by training the model to adaptively decide how many search steps it needs. For straightforward questions, it stops early. For complex, multi-hop questions that require gathering evidence from multiple sources, it uses additional steps up to a fixed limit.

This approach solves a real problem in enterprise data retrieval. Companies need search that is both accurate and fast, but these goals often conflict. Databricks' earlier Instructed-Retriever-1 model excelled at single-step parallel search, handling simple queries quickly. However, harder questions with multiple layers of reasoning benefited from sequential search, where the model iteratively gathers evidence and refines queries over multiple steps, at the cost of added latency.

How Does Adaptive Instructed-Retriever Learn to Search Smarter?

The model was trained using online reinforcement learning, a technique that rewards the system for making good decisions. Specifically, Databricks used a method called CISPO (Clipped Importance Sampling Policy Optimization), which balances two competing goals: achieving high-quality search results while penalizing unnecessary search steps. The reward design encourages the model to take additional steps only when they are likely to improve final performance.

To prepare training data, Databricks created synthetic enterprise retrieval environments and used an agentic data synthesis process. The team reused existing training data from Instructed-Retriever-1 to preserve the model's ability to do fast parallel single-step search, then introduced synthetic multi-hop questions that benefit from multiple search steps. The training recipe was intentionally lightweight, starting from a pretrained base model and using a modest amount of synthetic data to specialize its search behavior.

How to Implement Quality-Latency Tradeoffs in Your Search System

• Train a Family of Checkpoints: By adjusting the magnitude of the step penalty during reinforcement learning, Databricks created multiple versions of the model, each landing at a different point on the quality-latency frontier. This allows teams to pick the checkpoint that best fits their production workload and budget constraints.
• Favor Speed for Interactive Use: For real-time applications where users are waiting for answers, deploy a checkpoint optimized for lower latency, even if it means slightly lower retrieval quality on the hardest questions.
• Prioritize Quality for Offline Retrieval: For batch processing or non-interactive scenarios, use a checkpoint with a lighter step penalty, allowing the model to take more search steps and reach higher accuracy scores.
• Monitor Search Efficiency: Track how many steps the model takes on different question types to ensure it is learning to distinguish between simple and complex queries rather than applying a one-size-fits-all approach.

What Do the Benchmarks Show About Real-World Performance?

Databricks evaluated Adaptive Instructed-Retriever on a mix of proprietary enterprise retrieval tasks and public benchmarks, including questions that benefit from multi-hop reasoning. The results are striking: the model achieves performance comparable to leading third-party and open-source models while delivering 2x lower latency. Specifically, Adaptive Instructed-Retriever answers queries in just 5.8 seconds, more than twice as fast as Claude Sonnet 5, DeepSeek-V4-Flash, or GPT-5.6 Luna.

The trained frontier of Adaptive Instructed-Retriever models outperforms alternatives across the quality-latency spectrum. Compared with the untrained Instructed-Retriever base model, every checkpoint delivers higher quality at similar or lower latency, suggesting that the gains come from learning when to search and when not to. At the top of the frontier, the model reaches scores comparable to other leading models while being more than 2x faster.

How Does Adaptive Search Improve Over Brute-Force Approaches?

Databricks demonstrated the difference through concrete examples. On a question about whether a company explicitly reports restructuring costs as a line item, Adaptive Instructed-Retriever reached the correct answer in two steps by checking the direct line item and related expense categories, then stopping once the absence was established. In contrast, GPT-5.6 Luna took four steps, searching for speculative phrases like "There were no such costs" and "0 million," while Claude Sonnet 5 took three steps checking the statement of operations, restructuring note, and related reconciliations.

On a second example about which customers are using or considering LiteLLM Proxy, Adaptive Instructed-Retriever tied Claude Sonnet 5 for efficiency at two steps but achieved higher recall by using the second round for concrete account hypotheses, including two relevant customers. GPT-5.6 Luna again took four steps and later rounds repeated quoted combinations of "LiteLLM," "Proxy," and "customer" without finding new relevant information.

The key insight is that Adaptive Instructed-Retriever learns to adjust its search strategy based on the question type. For straightforward factual lookups, it stops early. For harder questions requiring synthesis across multiple sources, it uses its remaining search budget more effectively by formulating targeted hypotheses rather than repeating generic queries.

This work represents a broader shift in AI development toward test-time compute, where models use variable amounts of computation at inference time to match the difficulty of each task. For enterprise search, this means faster responses for common queries and better accuracy for complex ones, all within predictable latency budgets. Databricks has made this training approach available to customers through its AI Runtime platform, enabling teams to develop specialized models for their own domains and workloads.