Your Deep Research Agent Is Slow Because It Writes One Word at a Time — Diffusion Just Made It 6x Faster

Ask a deep research agent a hard question and go make coffee. The answer will probably still be coming. We tend to blame the model — too small, too dumb, too cautious. A new paper says the real culprit is much more mechanical: your research agent writes one word at a time, and every stage of its work inherits that speed limit. Swap out that one mechanism, the researchers show, and the same agent scaffold runs roughly six times faster — with no loss in report quality.

What the researchers did

The paper is "DiffResearch: Accelerating Deep Research with Diffusion Language Models" by Alan-Barsag Gazzaev, Alexey Gavrilov, Mikhail Mozikov, and Sergey Muravyov, submitted to arXiv on 20 October 2026. It tackles a bottleneck anyone who has used a research agent will recognise: deep research is iterative — plan, gather evidence, synthesise, revise, repeat. When each step is slow, the whole job is slow, and that latency is what makes research agents painful to use interactively.

Almost every production research system today is built on an autoregressive language model: the familiar left-to-right way of writing, one token after another, never revising an earlier word except by generating more words after it. Planning and long-form writing both inherit that rhythm.

DiffResearch replaces the engine, not the car. The team built an open, multi-agent deep research framework and put a diffusion language model (dLLM) at the core of every stage. A diffusion model works differently: instead of writing strictly left to right, it starts from noise and refines many parts of the output together, in parallel, until the text is clean. The crucial part is what they held fixed: the agentic scaffold, retrieval code, prompts, and evaluation stayed exactly the same — only the backbone was swapped, between an open diffusion model and a comparable autoregressive model. So any speed difference comes from the decoding mechanism itself, not from a better prompt or a bigger model.

Across 100 Deep Research Bench tasks, the diffusion backbone finished roughly 6 times faster end to end, driven by order-of-magnitude reductions in planning and writing — where long, sequential text generation dominates.

Then the team added a second trick, called dFast. In a diffusion model, the intermediate steps — the half-cleaned drafts on the way to the final text — already contain useful structure. dFast reads those intermediate denoising states and pulls out subqueries before generation finishes: the system starts splitting the work early, from the rough draft of the plan itself, instead of waiting for a finished plan. On its own, dFast gave a 1.99x median speedup for decomposition, with no loss of report quality, and earned the best overall score of the three configurations tested on the benchmark's RACE rubric.

Finally, in a public leaderboard snapshot, an instance built on a stronger diffusion model ranked above several commercial systems. DiffResearch itself is released under an Apache-2.0 licence, so anyone can inspect, run, and build on it.

Why it matters

This result separates two things we usually lump together: how smart an agent is, and how fast its engine runs. A large chunk of research-agent slowness is not intelligence at all — it is plumbing. A model refining a whole plan or draft in parallel simply waits less.

That has three practical consequences. First, interactive research becomes plausible: if a job drops from thirty minutes to five, you can iterate with the agent instead of firing off a job and coming back later. Second, speed compounds: faster planning means more plans tried, and faster writing means more revisions in the same budget. Third, the dFast idea generalises — "don't wait for a perfect plan before decomposing the work." Any agent pipeline with a slow planning stage can borrow that: extract usable sub-tasks from partial plans early, and let retrieval start while the plan is still being refined.

One honest caveat: the 6x figure comes from a controlled swap on one benchmark with comparable models. It is not a promise that every research agent gets 6x faster tomorrow, nor a claim that diffusion models reason better. It is a claim about latency at equal quality, on this benchmark, with this scaffold — and latency is what stands between research agents and everyday use.

How YOU can use it

You do not need to wait for your favourite research product to adopt diffusion models. Here is how to apply this paper this week:

1. Try the open framework yourself

DiffResearch is open source under Apache-2.0. If you run research agents, clone it and run the same question through it and through your current setup, timing both end to end. Split the timing into stages — planning, retrieval, synthesis, revision — to see whether your bottleneck matches the paper's: planning and writing. If it does, a backbone swap, not a bigger model, may be your cheapest upgrade path.

2. Steal the dFast pattern for your own agents

Even with an autoregressive model, you can decompose early with a planning prompt like this:

You are the planning stage of a research agent.
Do NOT write a perfect plan first. Instead, output:
1. The 3-5 most load-bearing subquestions (even if rough).
2. For each: the first search query to run.
3. What evidence would change your mind on each one.
Start retrieval immediately; refine the plan in parallel
as evidence returns.
Question: [paste your research question here]

This mirrors the paper's core move: subqueries from a partial plan, retrieval starting before the plan is finished. Measure the time saved on decomposition alone — the paper's 1.99x median for that stage is your reference point.

3. Benchmark latency, not just quality

Most agent evaluations score only the final report. Add a latency column: time to first subquery, time to first draft, time to final report. The paper's method — hold scaffold, prompts, and retrieval fixed while swapping one component — is a template for any agent upgrade decision.

4. Design for interactive research

If your research jobs get dramatically faster, change the workflow, not just the wait. Shorten the loop: ask a narrower question, read the draft, redirect the agent, repeat. The real promise is research you can steer while it happens.

Key takeaways

• Research agents are slow largely because autoregressive models write one token at a time — planning and writing inherit that limit.
• DiffResearch swaps in a diffusion model at every stage, holding scaffold, retrieval, prompts, and evaluation fixed — and runs roughly 6x faster end to end on 100 Deep Research Bench tasks.
• dFast extracts subqueries from intermediate denoising states before generation finishes: 1.99x median faster decomposition, no quality loss, best overall RACE rubric score tested.
• An instance on a stronger diffusion model ranked above several commercial systems in a public leaderboard snapshot.
• The framework is open source (Apache-2.0) — and "decompose early, don't wait for a perfect plan" works in your own agents today.

Read the original paper: DiffResearch: Accelerating Deep Research with Diffusion Language Models (arXiv:2610.28909) by Alan-Barsag Gazzaev, Alexey Gavrilov, Mikhail Mozikov, and Sergey Muravyov.