Diffusion Intelligence Releases Clover-35B, Doubling Agent Speed Over Autoregressive Models

How to Build Agents with Diffusion Models?

By Henry from Aofeisi QbitAI | WeChat Official Account: QbitAI

I’m stunned! Even as someone constantly riding the wave of AI, I can’t keep up with the latest versions.

Who would have thought that diffusion models, traditionally used for image and video generation, could now write code, generate web pages, call tools, and act as Agents?

Just moments ago, Diffusion Intelligence released a new Diffusion Language Model—

Clover-35B-A3B-Preview.

Despite having "Diffusion" in its name, the actual experience is quite similar to familiar Large Language Models (LLMs) when it comes to writing code, operating web pages, calling tools, or generating HTML.

My first impression after using it was simply one word: "Fast."

For example, when asked to generate a solar system simulator, Clover took about 1 second to think, and within another 4–5 seconds, an interactive solar system simulator was ready.

Another example: I threw a bunch of resume information at it and asked it to organize them into LaTeX-formatted resume code. It got done in just over ten seconds~

To be fair, anyone who has used GPT knows the feeling of staring at "Thinking..." for ages. That’s why there’s been so much buzz recently about Jev, which focuses on rapid decision-making.

Speaking of Jev, Clover actually competed against it in terms of speed this time.

In the WindTunnel Web Agent benchmark, across 49 tasks with 3 attempts each, Clover had a median execution time of 1.52 seconds, while the Jev + Mercury 2.5 combination took 3.21 seconds—more than twice as fast.

The success rate was also slightly higher, at 98.6% versus 95.9%.

Compared to Gemini in the same table, the speed advantage is even more pronounced—several times faster!

Alright, alright, you diffusion model, are you trying to drive autoregressive models crazy? (doge emoji)

Diffusion Models Capable of Agent Tasks

Back to the model itself. Clover-35B-A3B-Preview adopts a Mixture-of-Experts (MoE) architecture, with 35 billion total parameters and approximately 3 billion active parameters per token. It supports a thinking mode.

This release further advances the team's diffusion language model from the previous Dream 7B's 7 billion parameters to a total scale of 35 billion parameters.

More importantly, despite the increase in parameter count, Clover’s speed did not degrade; it outperformed autoregressive models of comparable size.

Beyond the interactive page and code generation mentioned earlier, official demos showed Clover handling complex tasks and WebUI generation as part of its Agent capabilities.

Using WebMCP, Clover sequentially processed six tasks involving invoicing, course registration, amount aggregation, activity status queries, customer information retrieval, and invoice lookups.

As seen in the comparison video below, Clover not only completed the tasks successfully but also significantly outpaced Gemini 3.6 Flash in execution speed.

In an online shopping scenario, Clover was able to find a specific style of black T-shirt in size L, add it to the cart, fill in guest information, and complete the test checkout process as requested.

Honestly, the ability to handle such sequential tasks is what makes this demo noteworthy.

It’s worth noting that while diffusion language models offer the potential for parallel generation speed, their performance in Agent tasks has historically lacked stability:

Models might make errors in tool-calling formats or get stuck repeatedly attempting the same step without adjusting actions based on returned results.

Clover’s progress lies precisely in these sequential operations: calling tools, reading feedback, continuing execution, until the task is complete.

Specifically regarding benchmarks, according to data published by the team, Clover scored 65.3 on τ³ Overall and 67.9 on BFCL-v4 in tool-use evaluations, placing it among the top performers.

△ Image source: Diffusion Intelligence

After reviewing Agent tasks, let’s look at coding.

I also asked Clover to generate a web interface for a personal Agent. It looked quite professional, and the entire generation process took only about ten seconds.

In code evaluation, Clover also delivered impressive results.

On SWE-bench Verified, which tests problem-solving capabilities in real-world code repositories, it scored 73.6. On Terminal-Bench 2.1, which evaluates terminal task execution, it scored 51.7.

△ Image source: Diffusion Intelligence

From generating interactive pages to calling tools and completing business workflows, all the way to code benchmarks, Clover—as a diffusion language model—has indeed taken on many Agent-related tasks this time.

Hey, this gets interesting. How exactly does the diffusion approach, traditionally responsible for denoising images, generate text and write code when applied to language models?

Could the demos above really be AIGC-generated?

What Are Diffusion Language Models?

Generally, the autoregressive (AR) language models we are familiar with predict the next token based on the preceding context, generating one token at a time before moving to the next—a process often described as "word chain."

Here, a token can be simply understood as a fragment of text processed by the model.

Unlike autoregressive models, which perform serial prediction and generation token-by-token, diffusion language models adopt a different generation method: they allow multiple positions to update simultaneously, refining the output over several rounds to gradually arrive at the result.

△ Image source: AI Generated

Diffusion-based denoising can be understood as the process of gradually restoring masked or perturbed content into coherent text that fits the context.

Specifically, Clover employs block diffusion: it divides the content to be generated into several blocks. Blocks are processed sequentially, while multiple positions within each block are updated in parallel and reference one another.

This approach allows a single computation round to advance the generation of multiple positions, reducing the latency associated with token-by-token generation.

However, the ability to generate together does not mean the result is finalized in a single round.

Diffusion models typically require multiple denoising rounds to progressively converge on the final output. Too few rounds may leave the content under-refined, while additional rounds increase computational overhead.

In coding and Agent tasks, the context continues to grow. Previous requirements, executed actions, and tool return results can all influence subsequent steps, making the storage and retrieval of historical information an efficiency bottleneck.

Clover’s improvement strategy is to assign distinct roles to historical memory and current generation.

It restructures the Gated Delta Network (GDN) around block diffusion: already-generated context is compressed into a continuously updated state for later steps to read; meanwhile, the current block being generated uses bidirectional attention to allow tokens within the block to reference each other.

Simultaneously, Clover treats the readout of historical memory as an independent information unit, participating in attention calculations alongside current tokens. This allows the model to learn how to weigh prior context against current content. Furthermore, learnable block size calibration helps mitigate the dilution of historical information as block sizes increase.

In other words, these adjustments aim to better coordinate parallel generation, historical information utilization, and computational efficiency. This is key to Clover advancing diffusion language models into code and Agent tasks.

Beyond Clover, diffusion language models have gained significant attention over the past two years primarily due to two advantages over autoregressive models:

First, diffusion language models allow simultaneous generation at multiple positions, offering the potential to reduce the serial waiting time inherent in token-by-token generation. This potential is particularly noteworthy for Agents that need to repeatedly generate code and call tools.

Second, during generation, preceding and succeeding content can reference each other. Under a bidirectional modeling design, multiple positions can jointly adjust during iterations, providing an alternative way to handle dependencies between content segments. The intra-block interaction in Clover is one such implementation.

Around these possibilities, academia and industry have proposed various approaches.

ELF, which Kaiming He participated in this year, attempts to generate language in continuous embedding spaces; Google’s DiffusionGemma explores parallel text generation; and major domestic tech companies are also researching diffusion language models tailored for coding tasks.

While specific methods vary, everyone is trying to turn this alternative generation paradigm into usable capabilities and efficiency.

With Clover, the team has placed its progress directly into coding, tool calling, and continuous task execution, allowing users to test and validate it firsthand.

From DiffuSeq to Clover: The Next Step in Diffusion Intelligence

Finally, let us discuss the team behind Clover—

Diffusion Intelligence.

Reportedly, Diffusion Intelligence was co-founded by Professor Lingpeng Kong from the University of Hong Kong and his PhD students Gong Shansan and Ye Jiacheng. The team’s exploration of diffusion language models dates back to 2022.

That year, they proposed DiffuSeq, investigating how to use diffusion models for sequence-to-sequence text generation: given a piece of text, generate another piece conditioned on it.

A major hurdle at the time was adapting diffusion methods, which excel at processing continuous signals like images, to discrete natural language.

By April 2025, core team members contributed to the launch of Dream 7B, advancing the research to a 7-billion parameter language model.

According to results published at the time, Dream 7B achieved performance comparable to autoregressive models of similar scale on general, mathematical, and coding tasks, while demonstrating planning capabilities and flexibility in generation order.

Now, with Clover, the model scale has expanded further, with coding, tool calling, and continuous task execution becoming key highlights.

This trajectory has evolved from initially studying how to generate text to figuring out how to perform complex tasks correctly and quickly. Currently, the team is extending this work toward multimodal and edge-side applications.

It is reported that a multimodal version of Clover will follow. The team is actively working on combining diffusion language models with multimodal understanding and action generation, while continuing adaptation and validation for edge scenarios. Collaboration with Acrab is driving system adaptation and hardware-software co-validation for edge devices.

According to the team’s plans, future efforts will continue exploring larger-scale models, improving stability for long-horizon tasks, and advancing edge applications through inference optimization, quantization, and deployment adaptation.

To conclude, let us take a moment to speculate based on the newly released Clover:

When humans think, do we proceed sentence by sentence, or do we first form a vague overall picture and then gradually fill in the details?

Is the brain more like an autoregressive model, or a diffusion model?