Just now, the diffusion model has broken into the Agent's home field, with 35 billion parameters and twice the speed of Jev.
I'm blown away! Even as someone who keeps up with the latest AI developments on a daily basis, I still can't keep pace with the rapid version iterations.
Who could have imagined that the "diffusion model", which we previously associated exclusively with image generation and video generation, can now write code, generate web pages, call tools, and even function as an Agent!
Just recently, Diffusion Intelligence released its brand new diffusion language model —
Clover-35B-A3B-Preview.
Even though the name carries the word "diffusion", in actual use cases, whether it is code writing, web page operation, tool calling, or HTML generation, its usage is very similar to the familiar large language models we all know.
My first impression after personal use can be summed up in one word: "fast".
For example, when I asked it to generate a solar system simulator, Clover spent about 1 second thinking, and then only 4 to 5 seconds later, an interactive solar system simulator was ready.
For another example, I fed it a pile of resume information and asked it to organize it into LaTeX-formatted resume code, which was completed in just over ten seconds ~
To be fair, anyone who has used GPT knows exactly what it feels like to stare at the "Thinking" prompt waiting for a long time, otherwise there would not be the recent rise of Jev which focuses on fast decision-making ~
Speaking of Jev, Clover actually competed with it in speed this time.
Among the 49 tasks in the web Agent evaluation WindTunnel, each task was tried 3 times. Clover's median execution time was 1.52 seconds, while the Jev + Mercury 2.5 combination recorded 3.21 seconds, meaning Clover took more than half less time.
The success rate of attempts is also slightly higher, at 98.6% and 95.9% respectively.
Compared with Gemini in the same table, its speed is several times faster!
Alright alright, you diffusion model, are you trying to drive autoregressive models crazy? (doge)
A Diffusion Model That Can Handle Agent Tasks
Back to the model, Clover-35B-A3B-Preview adopts the MoE architecture this time, with a total of 35 billion parameters, activating about 3 billion parameters per token, and supports thinking mode.
It further advances the team's diffusion language model from the 7 billion parameters of the previous Dream 7B to a total parameter scale of 35 billion.
More importantly, as the parameter count rises, Clover's speed does not slow down accordingly, and it outperforms autoregressive models of the same size in head-to-head comparisons.
In addition to the interactive pages and code generation mentioned above, in the official demonstration, Clover also further demonstrated Agent capabilities such as complex task processing and WebUI generation.
Clover can continuously process six tasks through WebMCP, involving invoice issuance, course registration, amount aggregation, activity status query, customer information query and invoice information query.
From the comparison video below, we can see that Clover not only successfully completed the tasks, but also completely outperformed Gemini 3.6 Flash in execution speed.
In the online shopping scenario, Clover can also find the specified style, black, L-size T-shirt as required, add it to the shopping cart, fill in visitor information, and then complete the test checkout process.
To be honest, the processing of such continuous tasks is actually the noteworthy highlight of this demonstration.
It should be noted that although diffusion language models have the speed potential of parallel generation, their previous performance was not stable enough when handling Agent tasks:
The model may make mistakes in the tool calling format, and it is easy to repeatedly try the same step without adjusting actions according to the returned results.
Clover's progress this time is reflected in these continuous operations: calling tools, reading feedback, and continuing to execute until the task is completed.
Specifically for the Benchmark, according to the data released by the team, Clover scored 65.3 and 67.9 respectively in the τ³ Overall and BFCL-v4 evaluations related to tool usage, ranking among the top.
△
After looking at the Agent tasks, let's move on to the code.
I asked Clover to generate a web interface for a personal Agent. The result looks quite well-formed, and the whole generation process only took more than ten seconds.
On the code evaluation side, Clover also delivered a set of excellent results.
On SWE-bench Verified, which examines the ability to solve real code repository problems, it scored 73.6; on Terminal-Bench 2.1, which examines terminal task execution capabilities, it scored 51.7.
△
It can be said that from generating interactive pages, calling tools, running through business processes, to passing code evaluations, Clover as a diffusion language model has indeed taken on a lot of Agent work this time.
Well, this is really interesting. The diffusion idea that we remember is responsible for denoising and generating images, how does it generate text and write code when applied to language models?
Is it possible that all the demos above are really generated by AIGC?
What is the background of the diffusion language model?
Generally speaking, the familiar Autoregressive (AR) language model predicts the next token based on the previous context, generates one, and then generates the next one, which is commonly known as "word solitaire".
The token here can be simply understood as the text fragment processed by the model.
Compared with the one-by-one serial predictive generation of autoregressive models, diffusion language models adopt a different generation method: allow multiple positions to be updated at the same time, and then go through several rounds of refinement to gradually get the result.
△
The diffusion denoising here can be understood as gradually restoring the masked or disturbed content into text that conforms to the context.
Specifically for Clover, it uses block diffusion: divide the content to be generated into several blocks, the blocks advance sequentially, and multiple positions within the block are updated in parallel and refer to each other.
In this way, one round of calculation can promote the generation of multiple positions, reducing the waiting caused by one-by-one generation.
But the problem is that being able to generate together does not mean that the content can be written well in one round.
Because diffusion models often require multiple rounds of denoising to gradually finalize the results. If the number of rounds is too small, the content may not be adjusted properly; if there are too many rounds, the computational overhead will also increase accordingly.
When it comes to code and Agent tasks, the context will continue to grow longer. Previous requirements, already executed operations, and results returned by tools may all affect the next step, so the storage and reading of historical information has also become an efficiency issue.
Clover's improvement idea is to let historical memory and current generation perform their respective duties.
It reconstructs the Gated Delta Network (GDN) around block diffusion: the generated context is compressed into a continuously updated state for subsequent steps to read; the currently generated block uses bidirectional attention to allow tokens within the block to refer to each other.
At the same time, Clover takes the reading of historical memory as an independent information unit, which participates in attention calculation together with the current token, so that the model can learn how to weigh the previous context and the current content; through learnable block size calibration, it reduces the problem of historical information dilution after the block becomes larger.
In other words, the goal of these adjustments is to better coordinate parallel generation, historical information utilization and computational efficiency, which is also the key for Clover to further push diffusion language models to code and Agent tasks.
In addition to Clover, diffusion language models have attracted much attention in the past two years, mainly due to their two major advantages over autoregressive models:
On the one hand, diffusion language models allow multiple positions to generate at the same time, which has the potential to reduce the serial waiting caused by token-by-token generation. For Agents that need to repeatedly generate code and call tools, this potential is particularly noteworthy.
On the other hand, during the generation process, the content before and after can refer to each other. Under the design of bidirectional modeling, multiple positions can be adjusted together in the iteration, providing another way to handle the dependencies between content. The interaction within Clover's current block is one of the implementations.
Around these possibilities, academia and industry have already made different attempts.
ELF, which He Kaiming participated in this year, tries to generate language in a continuous embedding space; Google launched DiffusionGemma to explore parallel text generation; large domestic manufacturers are also researching diffusion language models for code tasks.
The specific methods are different, and everyone is trying to turn this alternative generation method into usable capabilities and efficiency.
This time, Clover has put its progress into code, tool calling and continuous tasks, and handed it over to users for hands-on testing.
From DiffuSeq to Clover, the next step of Diffusion Intelligence
Finally, let's talk about the team behind Clover —
Diffusion Intelligence.
It is reported that Diffusion Intelligence was jointly founded by Professor Kong Lingpeng from the University of Hong Kong and his doctoral students Gong Shansan and Ye Jiacheng. The team's exploration of diffusion language models can be traced back to 2022.
In that year, they proposed DiffuSeq to study how to use diffusion models to complete sequence-to-sequence text generation: given a piece of text, generate another piece of text conditionally.
One of the hurdles that had to be crossed at that time was to apply the diffusion method, which is good at processing continuous signals such as images, to discrete natural language.
By April 2025, core members of the team participated in the launch of Dream 7B, advancing the research to a 7-billion-parameter language model.
According to the results announced at that time, Dream 7B achieved performance comparable to autoregressive models of the same scale on general, mathematical and code tasks, and also demonstrated planning capabilities and flexibility in generation order.
Then for this Clover, the model scale continues to expand, and code writing, tool calling, and continuous task execution have all become the key displayed contents.
This route has gradually moved from the initial research on how to generate text to figuring out how to complete complex tasks correctly and quickly. Now the team is also extending to multi-modal and end-side scenarios.
According to the introduction, Clover will also launch a multi-modal version later. The team is promoting the combination of diffusion language models with multi-modal understanding and action generation, and continuously carrying out adaptation and verification of end-side scenarios. The cooperation with Acrab is promoting system adaptation and software and hardware co-verification for end-side scenarios.
According to the team's plan, they will continue to explore larger-scale models next, improve the stability of long-range tasks, and promote end-side applications through inference optimization, quantization and deployment adaptation.
At the very end, let's brainstorm with the newly released Clover:
When humans think, do they push forward sentence by sentence, or do they first have a vague overall picture, and then gradually fill in the details —
Is the brain more like an autoregressive model or a diffusion model?