Diffusion Models Are Starting to Take Over Agents

Diffusion Language Models Take Aim at Long-Horizon Agents for the First Time

A new model recently debuted that public materials describe as “the world’s first agentic diffusion model.” Its most noteworthy feature is not generation speed, but the fact that it brings diffusion language models into long-horizon agent tasks for the first time: during execution, the model can continuously inspect and revise unfinished plans, while supporting context windows of up to 128K.

This means diffusion language models are no longer merely trying to prove that they “can also produce a coherent passage of text.” Instead, they are moving directly into more challenging—and commercially valuable—scenarios such as coding agents, search agents, data analysis, and multi-tool orchestration.

Based on the information disclosed so far, the model’s core selling points can be summarized in three areas:

• It is trained for agent workflows, rather than ordinary conversations alone;
• During generation and execution, it can revisit and correct intermediate steps;
• Its context window has been expanded to 128K, bringing it closer to the practical range of mainstream autoregressive models.

The phrase “world’s first” needs to be qualified: it appears to be more of the developer’s summary of the product’s positioning than a technical conclusion that has gained consensus across academia. Previous research has already applied diffusion language models to search, code generation, and tool use, while some systems have demonstrated the ability to reason and act concurrently. The real step forward this time is bringing agent capabilities, long context, and diffusion-based generation together in a single usable model, rather than remaining confined to short-sequence experiments.

It Generates Differently From GPT and Claude

Today’s mainstream large language models generally use autoregressive generation: they generate the first token, then generate the next token based on everything that came before it, proceeding from left to right.

This mechanism is like writing with a fountain pen. If the model makes a mistake earlier on, it cannot simply erase the incorrect word. It can only add something like “correction” later, or rely on an external agent framework to initiate another model call. This is not a serious problem for ordinary conversations, but in long-horizon agent tasks, early errors can continue propagating through everything that follows.

For example, suppose an agent is asked to complete a cross-repository code migration. It may need to:

1. Read the requirements and multiple code directories;
2. Identify interface definitions and call relationships;
3. Develop a modification plan;
4. Invoke search, terminal, and editor tools;
5. Run tests;
6. Reassess the problem based on error messages;
7. Modify the code and verify it again.

If an autoregressive model misjudges a dependency in step two, the subsequent plan will usually be built on a false premise. Although frameworks such as ReAct, reflection, and tree search can prompt it to replan, this essentially amounts to “starting another round after something goes wrong,” at the cost of more tokens, more model calls, and higher latency.

Diffusion language models take a different approach. They can first generate a candidate output containing many uncertain positions, then gradually complete and revise the entire sequence over multiple rounds of denoising. By analogy, instead of writing from left to right with a fountain pen, they sketch a draft on a whiteboard and then adjust the title, steps, and details simultaneously.

For agents, this distinction matters. A rough execution process might look like this:

• First, form a global draft of the task;
• Determine which steps have high confidence and which remain ambiguous;
• Prioritize tool calls and critical dependencies;
• After receiving tool outputs, denoise the still-undetermined steps again;
• Preserve the parts that have already been validated while revising conflicting portions of the plan.

In other words, the potential advantage of diffusion models is not simply that they are “better at reflection.” Rather, plan revision becomes part of the model’s native generation process instead of a patch added by an external agent framework.

What Is Actually New About “Correcting Errors While Acting”?

Past agents could also correct errors. Claude Code, various Deep Research systems, and open-source agents based on ReAct all reanalyze a task after a tool returns an error. So what is different this time?

The key is where the correction takes place.

A traditional agent loop typically works like this: the model generates a piece of reasoning or a tool call, the system executes the tool, the result is appended to the context, and the model continues generating from the end. The previously generated history is generally read-only. If there is a problem with the initial plan, the model can only generate a new plan to supersede the old one, while the old content continues to occupy context space.

Agentic diffusion models attempt to place “generation” and “revision” within the same inference process. In theory, the model can use the latest observations to adjust multiple steps that have not yet been executed, rather than being limited to changing only the next action immediately following its current position.

This is particularly suitable for three types of tasks.

1. Coding Agents

Code modifications are rarely completed in one pass. Test results can change the model’s understanding of the code structure, while a type error may indicate that the original interface design was invalid from the outset.

Diffusion-based generation may allow the model to reevaluate multiple related changes simultaneously instead of patching files one by one. For cross-file refactoring, dependency upgrades, and debugging large repositories, this is more meaningful than simply increasing tokens per second.

2. Search and Research Agents

Information in research tasks does not appear in sequence. An agent may discover a critical fact on the tenth webpage that overturns assumptions used in the previous eight searches.

Traditional models generally need to summarize everything again or even restart the task. A diffusion model, by contrast, can propagate new evidence throughout the entire intermediate plan, readjusting the remaining search questions, evidence priorities, and final report structure.

3. Multi-Tool Workflows

When switching among databases, browsers, terminals, and internal enterprise APIs, tool outputs are often uncertain. An API timeout does not necessarily mean the plan is wrong, while an empty field may require the entire workflow to take a different route.

Only if the model can distinguish between a “local execution failure” and a “global assumption failure,” then revise the appropriate layer, does an agent have a chance to evolve from merely being able to call tools into a system capable of completing projects reliably.

However, correcting errors while acting does not mean the model can rewrite history at will. Real systems must lock actions that have already been executed and produced external side effects. For example, once an email has been sent or an order has been created, the model cannot roll back reality simply by revising its internal plan. Diffusion-based agents therefore still need explicit commit boundaries, permission controls, and idempotency mechanisms.

The Significance of 128K Is Not Just “Fitting in More Text”

One obvious weakness of early diffusion language models was sequence length. Text diffusion generally requires repeated computation across a large number of positions. As sequences grow longer, denoising costs, memory usage, and scheduling complexity all rise rapidly. This is also why diffusion models could demonstrate parallel generation on short text but struggled to take over complex agent tasks directly.

Expanding the context to 128K at least indicates that long-sequence modeling has entered a usable range. A 128K window is sufficient to hold key files from a medium-sized codebase, extended tool-use trajectories, or dozens of curated research documents.

But “supporting 128K” does not mean “using 128K effectively.” Developers need to distinguish among four things:

• Window length: The maximum number of tokens the API allows in a request;
• Long-range recall: Whether the model can retrieve critical facts from tens of thousands of tokens earlier;
• State consistency: Whether constraints and variables remain consistent after multiple rounds of revision;
• Computational cost: Whether latency and pricing remain acceptable as the context grows.

Autoregressive models have already built mature engineering ecosystems around KV caches, sparse attention, context compression, and inference services. Expanding diffusion models to 128K merely earns them a seat at the table; it is far from proving that they have won on long-context efficiency.

In particular, it is necessary to clarify whether 128K refers to input context, the combined input-output window, or the sequence length the model can generate in a single diffusion process. These pose entirely different engineering challenges. If the model can merely read 128K while generating only short actions in each round, it is already valuable for existing agents. If it can perform broad parallel revisions across an ultra-long intermediate state, the implications would be much greater.

Diffusion Models Are Not Necessarily Faster by Nature

Diffusion language models are often promoted as being faster than autoregressive models because they can generate multiple tokens in parallel. That claim is only half true.

To generate 1,000 tokens, an autoregressive model theoretically requires 1,000 sequential decoding steps. A diffusion model can predict multiple positions simultaneously, but it requires multiple rounds of denoising. If improving quality requires repeatedly running many rounds of network computation, actual latency may not be lower.

Moreover, the agent experience is determined not by the speed of a single text-generation pass, but by the end-to-end task duration:

Total time = model inference + tool execution + context processing + failure retries + verification costs

If a diffusion model is 20% faster at every step but more likely to generate invalid tool parameters, it may ultimately be slower. Conversely, even if a single inference pass offers no order-of-magnitude advantage, reducing the number of times a plan must be discarded and rebuilt could deliver substantial gains on long-running tasks.

This means such models cannot be evaluated solely by tokens per second. More valuable metrics include:

• The number of model calls required to complete a real task;
• The validity rate and execution success rate of tool-call parameters;
• The probability of recovering a task after an intermediate error;
• The task completion rate under a fixed token or cost budget;
• The proportion of repeated calls, infinite loops, and goal drift across long trajectories;
• Whether dangerous actions are executed repeatedly when external side effects are involved.

This remains the biggest unanswered question surrounding the release: the architectural story is compelling, but whether it translates into higher agent success rates will depend on third-party testing of long-horizon tasks, not a handful of generation demos.

The Real Competitor Is “Autoregressive Models Plus Engineering Systems”

This model is not competing against a bare-bones GPT or Claude. It is competing against highly engineered autoregressive agent stacks.

Mature solutions today typically combine planners, executors, memory modules, context compression, caching, validators, and retry strategies. They may not be elegant, but they already work. If diffusion models are to replace these solutions, they must do more than prove that they have a more elegant internal error-correction mechanism. They must also demonstrate that they can reduce the number of external modules while preserving stability and observability.

Our assessment is that, in the short term, agentic diffusion models are more likely to become specialized execution engines than to immediately replace all autoregressive models.

One practical architecture would use an autoregressive large language model, which excels at understanding complex instructions, to decompose tasks and make safety decisions, while assigning the diffusion model to handle code, search plans, or structured drafts that require extensive local revisions. Another possibility is for the diffusion model to serve as a speculative planner, generating multiple sets of revisable candidate actions at once and passing them to a validator for selection.

Hybrid architectures may reach production faster than any scenario in which one approach completely replaces the other.

What Developers Should Focus On Now

As of July 28, this debut looks more like an important technical signal than the start of an already-settled platform migration. The model’s name and the label “world’s first” matter less than the following questions:

1. Is the tool-calling protocol stable? The ability to output strict JSON, make parallel calls, and handle exceptions reliably directly determines whether the agent is usable.
2. Can the denoising process be controlled? Can developers lock validated steps and allow the model to modify only local regions?
3. What is the effective recall rate at 128K? Long context is not a capacity test; it is a test of the ability to preserve constraints.
4. How are inference costs calculated? The number of diffusion steps, caching strategy, and concurrent throughput will determine the actual bill.
5. Are reproducible evaluations available? What is needed are real repositories, browser tasks, and multi-hour workflows—not leaderboards for short answers.
6. Are failures observable? If the model repeatedly revises its work internally, can the platform expose those trajectories so developers can diagnose problems?

If these questions receive satisfactory answers, agentic diffusion models could become a genuinely significant branch of the model architecture race in 2026. They target precisely the areas that autoregressive models struggle with most: early errors, long-range dependencies, and plans that must continually adapt to external feedback.

Conversely, if “correcting errors while acting” is merely a repackaging of the familiar ReAct loop, and 128K is only the maximum input length supported at the API layer, existing models and agent frameworks will quickly catch up.

What is truly worth anticipating is not diffusion models winning a few more benchmarks, but agents becoming less likely to “stay wrong all the way through.” When they discover after a dozen steps that they are heading in the wrong direction, they should not need to start over. They should be able to preserve what is correct, rewrite what is wrong, and continue until the task is complete.

That is the capability an AI system needs to handle long-running projects.

References

• BAAI TALK: Search Agents “Thinking While Acting” and P-ReAct — Introduces the use of diffusion language models in search agents, as well as the technical background of parallel reasoning and action.
• LLaDA Project Repository — An open-source implementation of a diffusion language model that can help explain masking, denoising, and non-autoregressive generation mechanisms.
• LLaDA Paper Page — Foundational research materials on diffusion-based large language models, providing background on the architecture and training methods.