DiffResearch: A Diffusion LLM Makes Deep Research About 6x Faster

Researchers have introduced DiffResearch, an open-source multi-agent framework for deep research that builds every stage on a diffusion language model (dLLM), from planning to the final report. On 100 Deep Research Bench tasks, the system runs roughly 6x faster than the same design built on a comparable autoregressive model. The code is released under the Apache-2.0 license.

The main pain point of interactive deep research is latency. The system plans, searches for sources, consolidates facts and rewrites a draft, and at every step the model generates text left to right, one token at a time. Almost all production systems work this way. The DiffResearch authors tested what happens when you remove that constraint at the core.

Swapping the engine, keeping the chassis

The experiment is carefully designed. The agent scaffold, the retrieval code, the prompts and the evaluation method all stayed fixed. Only the backbone model changed: an open diffusion model versus a comparable autoregressive one. That lets the authors attribute the differences in speed and quality to the decoding architecture itself rather than to quirks of the pipeline.

The result is an end-to-end speedup of roughly 6x. Two stages, the ones where the model generates the most text, contributed most: planning and report writing. Time there dropped by an order of magnitude. A diffusion model does not emit tokens one by one. Instead, it refines an entire passage at once over several denoising steps, which pays off noticeably on long outputs.

dFast: sub-queries from unfinished text

The authors' second idea is the more interesting one. At each step, a diffusion model holds an intermediate, still-noisy state of the whole answer. The dFast mode reads these states and pulls out search sub-queries without waiting for generation to finish. Search starts before the model has finished writing the plan.

In isolated query decomposition, the median speedup was 1.99x, and report quality did not drop. On the benchmark's RACE rubric, dFast earned the best overall score among three configurations: autoregressive, standard diffusion and dFast itself. The key point is that the speed was not bought at the expense of quality.

Separately, the authors cite a snapshot of a public system leaderboard. A DiffResearch instance built on a stronger diffusion model ranked above several commercial systems. It is a snapshot from the time of measurement, but for an open-source dLLM project the result carries weight.

Key parameters of the work:

• Benchmark: 100 Deep Research Bench tasks, scored with the RACE rubric.
• End-to-end speedup: roughly 6x relative to the autoregressive model.
• Planning and writing: time cut by an order of magnitude.
• dFast: median decomposition speedup of 1.99x with no loss of quality.
• License: Apache-2.0.

Who should try what in production

Teams building research agents should look at latency by stage. If most of the time goes to long planning and writing steps, swapping the backbone gives the biggest payoff. The scaffold architecture can stay the same, as the fixed-scaffold experiment showed.

The second practical takeaway concerns pipelines that start search early. The dFast idea applies wherever the model's intermediate states are exposed: sub-queries can be sent to retrieval as they emerge in the draft. For autoregressive models, this trick is impossible in its pure form, because they have no "whole" picture until generation ends.

There are limitations, too. The comparison covers one benchmark and one pair of models, and strong diffusion models are still rarer than autoregressive ones. But the open license lets teams check the result on their own data and their own retrieval. If the numbers hold up, diffusion LLMs will get a convincing use case exactly where latency irritates users the most.