Clover-35B Review: DiffuSpace's 515 Tok/Sec Open Diffusion Model

This week a small Shenzhen startup did something the biggest AI labs have mostly talked about: it shipped a genuinely fast, genuinely open diffusion language model and gave away the weights. DiffuSpace's Clover-35B-A3B-Preview is a 35-billion-parameter mixture-of-experts model that writes text in parallel 32-token blocks instead of one token at a time — and the company says it does 515 tokens per second on a single NVIDIA H200. The weights are free under Apache 2.0, the model card and code are live on Hugging Face and GitHub, and the benchmark claims are bold enough to deserve a careful read.

Clover is DiffuSpace's first model release, and it arrives at a moment when diffusion language models are having their breakout month: Inception's Mercury 3 landed October 20 with a 1-million-token context, Liquid AI's LFM2.5 diffusion experiments are public, and Google's own Gemini Diffusion work is the reference point everyone cites. Clover's pitch is different from all of them on one axis that matters to builders — you can download it today and run it yourself, no API key, no usage bill, no waiting list.

What Clover-35B actually is

Most language models generate text autoregressively: one token, then the next, then the next, each step waiting on the last. A diffusion language model works more like an image generator. It starts with a block of masked positions, fills in the positions it is most confident about in parallel, and iterates until the block is complete. Clover uses block diffusion with what the model card calls LowConfidence decoding: each block starts fully masked, positions above a confidence threshold get filled together, and if none qualify, the single most confident position is filled so decoding always makes progress.

The defaults are a 32-token block size and a 0.95 confidence threshold. Under the hood is a mixture-of-experts backbone: 35 billion total parameters with roughly 3 billion active per token, 40 layers, 256 routed experts with top-8 routing per token, and one shared expert per layer. Context reaches 131,072 tokens for prompt and response combined. The architecture is a hybrid of full attention and Gated DeltaNet (GDN) layers, with additional learned bidirectional GDN parameters — including right-convolution weights and softmax controls — that let tokens attend within a noisy block while the already-decoded prefix stays causal.

One honest detail from the model card is worth flagging: Clover is derived from Alibaba's Qwen3.6-35B-A3B. The upstream weights carry Apache 2.0 licensing, and DiffuSpace keeps the upstream license and attribution notices in the repository. So "Clover" is not a from-scratch foundation model — it is a diffusion retrofit of an existing open MoE, which is exactly why the company could ship it fast and license it cleanly.

The numbers, with the fine print

Here is what the launch claims, and where each figure comes from:

• SWE-bench Verified: 73.6 — self-reported at launch, via the project's launch coverage. With only ~3B active parameters per token, that would be a striking score for a model this size. It has not been independently reproduced yet.
• Terminal-Bench 2.1: 51.7 — also self-reported, same caveat.
• tau-cubed: 65.3 and BFCL-v4: 67.9 — reported by launch coverage; both are agent tool-use and function-calling benchmarks, the tests that matter if you want this model driving a coding agent.
• 515 tokens per second on one NVIDIA H200 — reported at launch. The company frames this as roughly an order-of-magnitude jump over autoregressive decoding; the figure itself is company-reported.
• 680 tokens per second on one GB300 — also reported at launch, on NVIDIA's newer Blackwell-generation card.

Every one of these figures is company-reported or reported through launch coverage — as one tracker put it plainly, they "haven't been independently reproduced yet." That is the normal state of a week-old release, but it means the numbers are a claim to test, not a fact to quote. The model is explicitly a preview, and the Hugging Face repository was created October 24 with the model card updated October 28 — this is days old, with 105 downloads and 115 likes at the time of writing.

A smaller date discrepancy is worth noting for the record: the weights appeared on Hugging Face on October 24, the GitHub repository was created October 27, and the public launch wave hit on October 28–29. Different trackers date the "release" differently; the substance is the same.

Why diffusion is having a moment — and why code is the target

Diffusion language models are not new — DiffuSpace's own lineage goes back to DiffuSeq in 2022, published at ICLR 2023, and the company's Dream 7B (2025) was listed alongside Google Gemini Diffusion and Inception Mercury as one of the three representative diffusion LLMs in an ICML talk. What is new is the engineering: block diffusion turns the sequential bottleneck of token-by-token generation into parallel work, and parallel work is exactly what modern GPUs are built for.

Code is the natural first battlefield. Coding agents make dozens of short, latency-sensitive calls per task, so generation speed translates directly into how fast an agent feels and how much a session costs in wall-clock terms. DiffuSpace is explicit about the coding focus: Clover ships with a thinking mode, repetition penalties, and biases designed to close out long responses and long reasoning phases — the failure modes that matter when a model writes a 500-line diff. It also supports self-speculative decoding in the company's SGLang and llama.cpp implementations for serving.

The October diffusion roll call, for context: Inception's Mercury 3 (covered in our October 20 speed-duel comparison) is the closed-weights speed leader; Liquid AI's LFM2.5-350M-Diffusion-Exp is the tiny experimental end of the spectrum; DiffuSpace's own Dream 7B is the predecessor with a reported 2.5 million-plus Hugging Face downloads. Clover is the first one in this wave you can self-host at 35B scale under a permissive license.

How to run it

The practical path, straight from the official material:

1. Grab the weights from the Hugging Face repository (Diffuspace/Clover-35B-A3B-Preview) — safetensors format, transformers-compatible, conversational template included.
2. Budget the memory: the BF16 checkpoint needs about 69 GB, so this is an 80GB-class GPU job (H100 80GB or H200 141GB), not a laptop or a 24GB desktop card.
3. Use the official serving stack. DiffuSpace recommends its SGLang implementation for serving and evaluation — the model card warns that the standalone PyTorch path can produce slightly different text under identical settings because of small numerical differences in the kernels. llama.cpp support with self-speculative decoding is also in the GitHub repository for the official setup instructions and decoding modes.
4. Start with the defaults (block size 32, confidence threshold 0.95) and the thinking mode on for coding tasks; the generation controls for repetition and response-ending are the dials the card documents for long outputs.

There is no DiffuSpace-hosted API, no playground, and no per-token price list. If you want to try Clover without renting a GPU first, your options are the community: expect quantizations and inference endpoints from third parties to appear within days, as they always do for Apache 2.0 releases. Check what is actually live rather than assuming — this model is a week old.

The price of "free"

The weights cost $0 and the license is Apache 2.0, which permits commercial use — DiffuSpace preserves the upstream Apache 2.0 license and Alibaba's copyright notices in the repo, so keep the attribution files intact. But "free model" does not mean "free to run," and the fine print is the GPU bill:

• The hardware bar: ~69 GB for BF16 weights means a single 80GB-class card minimum. Quantized builds will lower this, but none are official yet.
• What an hour costs: tracked rental rates from late October put an H100 80GB at about $1.99/hr on the cheapest community clouds and an H200 141GB at $3.59/hr cheapest, with medians around $5.70/hr on-demand and DigitalOcean listing $4.47/hr. Prices move by the day and by provider — always check the vendor page before you rent.
• What a weekend of tinkering costs: 20 hours on a community-cloud H100 at ~$2/hr is about $40; on a mainstream H200 at ~$4.50–$5.70/hr it is $90–$114.
• What always-on serving costs: one H200 at $4.47/hr for a full month is roughly $3,263 before storage, egress, and taxes — which is why nobody self-hosts a 35B model casually.
• What is missing: no hosted API means no per-token price exists to compare against. The honest comparison is against API models in the coding-agent roundup — where you trade per-token bills for a fixed GPU-hour bill and full control of the weights.

So the real accounting: DiffuSpace charges nothing; your cloud provider charges by the hour; and the 515-tokens-a-second headline was measured on an H200-class card, not on hardware you own.

Pros and cons

Pros: genuinely free Apache 2.0 weights with clean upstream licensing; a real speed story — parallel block generation is a structural advantage, not a benchmark trick; 128K context in a 35B-class open model; thinking mode and generation controls aimed at coding workloads; SGLang and llama.cpp serving support from day one; a team with a real diffusion lineage (DiffuSeq, Dream 7B) rather than a weekend fork.

Cons: every benchmark figure is company-reported and none has been independently reproduced; it is explicitly a preview — expect rough edges and frequent updates; 69 GB of VRAM prices out laptops and most desktops; no hosted API or playground, so there is no try-before-you-rent path from the vendor; derived from Qwen3.6-35B-A3B, so its ceiling is bounded by the base model's capabilities plus the diffusion retrofit; and the GitHub repository is days old with a small star count — community tooling is just beginning.

Clover vs the diffusion pack

The table tells the strategic story in one glance: Mercury 3 is faster to try but closed; Qwen3.6 is the same weights without the diffusion trick; Dream 7B is the small sibling. Clover is the only 35B-class diffusion model you can download and own outright — which is exactly the gap DiffuSpace is betting on.

Who is DiffuSpace, anyway

DiffuSpace (KuoSan Intelligent, Shenzhen) was co-founded by Professor Kong Lingpeng, co-director of the NLP lab at the University of Hong Kong, with his PhD students Gong Shansan and Ye Jiacheng; core members come from Tsinghua, Peking University, HKU, and CMU. The company has raised several hundred million RMB across two rounds, co-led by Matrix Partners China with Shunwei Capital and Legend Capital participating. Its public track record is Dream 7B (2025), which the company says surpassed same-scale autoregressive models on math, code, and planning — and which racked up a reported 2.5 million-plus Hugging Face downloads. Clover is the company's first release since that funding, and the step up from 7B to 35B is the test of whether the diffusion approach scales past the research-demo stage.

FAQ

What exactly is a diffusion language model?

A normal LLM writes one token at a time, left to right. A diffusion LM starts with masked (hidden) positions and fills them in parallel, keeping the ones it is most confident about and re-trying the rest. Clover does this in blocks of 32 tokens. The payoff is speed: independent positions decode simultaneously instead of waiting in line.

Can I run Clover-35B-A3B-Preview on my laptop?

No — the BF16 weights need about 69 GB of VRAM, so you need an 80GB-class data-center GPU (H100 or H200) or a multi-GPU setup. Quantized versions will shrink that, but none are official yet. For most people, the practical route is renting a cloud GPU by the hour.

Is it really free for commercial use?

The weights are Apache 2.0, which permits commercial use, modification, and redistribution. The fine print: keep the upstream license and attribution notices that DiffuSpace ships in the repository, and remember this is a preview release with no warranties — test it before you build a business on it.

How is it different from the Qwen3.6 model it is built on?

Qwen3.6-35B-A3B is an autoregressive MoE — one token at a time. Clover keeps the same backbone and weights but adds block-diffusion inference, bidirectional GDN parameters, and generation controls (repetition penalties, thinking mode, response-ending biases). Same knowledge, different engine.

Should I trust the benchmark numbers?

Not yet, not fully. SWE-bench Verified 73.6, Terminal-Bench 2.1 51.7, and the 515–680 tokens-per-second figures are all company-reported or reported through launch coverage, and at least one tracker explicitly notes they have not been independently reproduced. Treat them as a claim to verify — the weights are public, so the community will do exactly that within weeks.

Key takeaways

• DiffuSpace's Clover-35B-A3B-Preview is a 35B-parameter (3B active) diffusion language model with free Apache 2.0 weights, live on Hugging Face and GitHub since this week.
• It generates text in parallel 32-token blocks instead of one token at a time, with reported speeds of 515 tokens/sec on an H200 and 680 on a GB300.
• Reported benchmarks include 73.6 on SWE-bench Verified and 67.9 on BFCL-v4 — all company-reported, none independently reproduced yet.
• The model is free; running it is not — the 69GB BF16 checkpoint needs an 80GB-class GPU, roughly $2–$6 per rented hour depending on card and provider.
• It is a preview, derived from Qwen3.6-35B-A3B, with no vendor-hosted API — download it, rent a GPU, and verify the claims yourself.

Diffusion language models spent years as a research curiosity. In October 2026 they became a product category — and Clover-35B is the first one in the category you can take home. The benchmarks will either hold up or they won't; either way, the weights are public, the license is clean, and the next few weeks of community testing will tell us whether block diffusion is the future of fast open models or just a very fast preview.