ZeroSearch: Teaching LLMs to Search Without a Search Engine

> Paper: Hao Sun et al., "ZeroSearch: Incentivize the Search Capability of LLMs without Searching", arXiv:2505.04588, 2025

The Core Paradox

If you want to teach someone to swim but the pool is temporarily unavailable, what do you do?

ZeroSearch's answer: let an LLM learn to search without ever connecting to a real search engine.

That sounds like a paradox—how can you learn without practicing? Yet the paper shows a surprising result: models trained in a simulated environment can match or even outperform models trained against real search engines on real search tasks.

What the Paper Actually Does

Traditionally, training an LLM's search ability required: 1. Calling a real search engine (Google, Bing) 2. Getting real retrieval results 3. Training the model on those results

Problems with this approach:

• Real search APIs are expensive
• Results are unstable (the same query can return different results today vs. tomorrow)
• During training the model generates many "garbage queries," wasting API quota
• Network latency makes training slow

ZeroSearch's core innovation: use an LLM (typically a stronger model, e.g., GPT-4) to simulate the search engine.

Concretely:

• During training, the policy model generates a query
• Instead of calling a real search engine, a "simulated engine" (another LLM) generates the retrieval results
• The simulator is instructed: "Pretend you are a search engine; what results should this query return?"
• Training continues based on the simulated results

A Feynman-Style Check: Is This Scientifically Sound?

Here is a concrete test of the method's plausibility.

Imagine learning to drive. Someone says: don't drive a real car—just sit in a simulator where an experienced driver tells you "if you turn the wheel now, the car will move like this." Would that produce a road-ready driver?

Intuitively: no. No matter how realistic the simulation, it lacks the noise and surprises of the real world.

But ZeroSearch's experiments say: yes. On some tasks, models trained with ZeroSearch even beat those trained with a real search engine.

Why?

The answer lies in the signal-to-noise ratio of training data.

Real search results contain lots of noise—ads, SEO spam, irrelevant pages, outdated information. A model in training must learn not only "how to search" but also "how to filter noise." For a model still acquiring basic search skills, that burden is heavy.

A simulated search engine may be "less real," but its results are cleaner, more relevant, and more predictable. The model can focus on the two core capabilities—query generation and information integration—without distraction.

It's like learning to drive in an empty parking lot before facing real traffic. ZeroSearch is that empty parking lot.

Key Findings

Experiments on Natural Questions, TriviaQA, MuSiQue, and other datasets show:

• ZeroSearch approaches real-search training on single-hop QA
• On multi-hop QA, ZeroSearch even surpasses real-search training (multi-hop benefits more from "clean" intermediate results)
• Training cost drops by an order of magnitude (no API calls)
• Training speeds up 5-10x (no network latency)

The paper is also honest about limits:

• Tasks requiring real-time information fail completely (the simulator doesn't know today's news)
• Tasks needing deep domain-specific knowledge risk "plausible but wrong" simulated results (hallucination contagion)
• The simulator's capability ceiling caps the training outcome

The Real Insight

The most interesting part of this paper isn't the technical detail—it's the methodological insight:

When learning a complex skill, a "simplified environment" can be more efficient than a "real environment"—provided the simplification preserves the core structure.

This matches how humans learn. In math, we start with idealized geometric figures, not measurements of irregular real-world shapes. In physics, we assume a frictionless plane before adding complexity.

ZeroSearch applies this principle to LLM training: let the model learn the structure of search in an idealized information environment, then transfer to the real one.

But there is a critical assumption: the simulator must be strong enough. If the simulator itself lacks domain knowledge, its simulated results will systematically mislead the student model.

A Critical Perspective

One point worth questioning (in the Feynman spirit): the paper used GPT-4 as the simulator. That means the whole method presupposes a model far stronger than the one being trained.

It's like saying: "Want to learn to drive? First find an F1 driver to sit in the passenger seat and coach you." But what if that F1 driver doesn't exist?

In the open-source ecosystem, people typically train a 7B or 32B model with another model of similar scale. There, the simulator isn't clearly stronger than the student, and ZeroSearch's gains may shrink substantially.

The paper doesn't fully explore this capability asymmetry—a question worth follow-up research.

Conclusion

ZeroSearch is an elegant engineering solution—replace real with simulated, cut costs, accelerate training.

But it's not a silver bullet. Its effectiveness depends on three conditions: 1. A sufficiently strong simulator 2. Tasks that don't demand real-time information 3. Domain knowledge within the simulator's coverage

For industry: ZeroSearch is an excellent training accelerator during rapid development iteration, but real-environment fine-tuning and validation are still needed before final deployment.

For academia: ZeroSearch opens a research direction—designing "structure-preserving, noise-free" training environments so models learn core capabilities efficiently rather than wandering randomly through real-world noise.

> Remember the saying: you can name that bird in every language on Earth and still know nothing about the bird. ZeroSearch lets you learn to identify the bird without ever seeing it—but someday, you still have to walk into the forest and look at a real one.