What Is Clover-35B-A3B? A Diffusion Language Model That Rewrites Whole Blocks in Parallel

Quick Answer

A diffusion language model rewriting whole blocks in parallel: 35B total, 3B active; all scores vendor-reported.

Classic language models write one token at a time: produce the first token, feed it back, produce the second. Clover-35B-A3B-Preview, released by DiffuSpace on October 28, 2026, takes a different route: it drafts a whole block full of blanks, then revises it over several parallel passes, filling the positions it is confident about all at once. That is a diffusion language model — not painting from noise, but editing a placeholder-filled draft into fluent text. The model has 35B total parameters with only about 3B active per token, is open under Apache-2.0, and its weights and code are on Hugging Face and GitHub. Three things to get straight first: every score and speed figure is vendor-reported (preliminary) with no independent reproduction yet; the “Preview” label is not modesty — long-task performance is unverified; and there is no API, so this article is about the mechanism itself, not a paid-site template.\n\nDisclaimer: this site is not affiliated with DiffuSpace. This article is product-technology reporting and analysis, not procurement, deployment, or investment advice. Scores and speed figures are vendor-reported and marked preliminary; deployment and license details follow official pages and may change.

1. What it is: from writing word by word to editing a whole draft

The fastest way to understand a diffusion language model is a different metaphor: an autoregressive model is like spoken composition — say one word, then think of the next. A diffusion model is like an editor revising a draft — lay out a version full of blanks, then fill the confident gaps over several rounds, one block at a time. Clover's default is 32 tokens per block: mask all 32 positions, fill the high-confidence ones in parallel, leave the rest for the next pass; if no position qualifies in a round, fill the single most confident one so progress never stalls.\n\nThis is not a new idea with a new name. DiffuSpace is the commercial continuation of the University of Hong Kong's NLP group, whose Dream 7B from April 2025 first showed a small diffusion model could hold its own against autoregressive models; the Dream family has since passed 2.7 million downloads on Hugging Face. Clover is the scaled-up version: roughly five times the size, and the first open diffusion model put directly against the autoregressive model it was built from (Qwen3.6-35B-A3B) with a claim to win. The launch blog's line is that at larger scale, diffusion models can even edge out similarly sized autoregressive models while generating significantly faster — “speed and performance can coexist in a single model.” The second half of that sentence (speed) has internal data behind it; the first half (performance) needs the caveat breakdown in section 3.

2. The mechanism: 32-token blocks, a 0.95 confidence threshold, bidirectional block attention

Clover's backbone is not mysterious: it keeps the Qwen3.6-35B-A3B structure — 40 layers, 256 routed experts with top-8 routing plus one shared expert per layer, a hybrid Gated DeltaNet / full-attention backbone, 35B total parameters with about 3B active per token. What DiffuSpace added is two things. First, block-diffusion decoding (called LowConfidence decoding in the official implementation): each block of 32 masked positions is filled in parallel by confidence, with a default threshold of 0.95 — a block closes when the model is sure, not when a step count runs out; resolved blocks become the prefix for the next block, so context rolls forward block by block. Second, bidirectional block attention: additional learned GDN parameters (including right-convolution weights and softmax controls) let tokens attend in both directions inside a noisy block while preserving a causal prefix — the key that makes diffusion editing work, since words in the same block can consult each other instead of only seeing what came before.\n\nTwo product-level facts. The model is text-only, not multimodal; and the 128K context is 131,072 tokens for prompt plus generation combined, not 128K of input plus another 128K of output. A thinking mode is officially supported, aimed at agentic coding and tool-use tasks — the source of its claim to lead six agent benchmarks. But a thinking mode is not long-task reliability, and in a Preview release that reliability is still an open question.

3. The numbers and their caveats: all vendor-reported, with two version traps

The vendor figures first, all marked preliminary: SWE-bench Verified 73.6, Terminal-Bench 2.1 51.7, τ³ Overall 65.3, GPQA Diamond 83.8, ZebraLogic 95.8, AA-LCR 72.0; the vendor claims the highest scores across six agent benchmarks against same-size autoregressive models Qwen3.6-35B-A3B and Qwen3.5-35B-A3B, as well as fellow diffusion models LLaDA2.2 flash and Mercury 2.5. On speed: 680 tokens/s on a single GB300 (BF16, batch size 1, internal agent workloads); 515 tokens/s on an H200, against 365 tokens/s for same-size Qwen accelerated with DFlash2.\n\nNow the two most misread caveats. First, the 0.2-point SWE-bench edge is not a settled win: 73.6 against Qwen's published 73.4, a gap of 0.2 points produced by different methods, with the baseline being the vendor's own re-run — not numbers from the same evaluation, as third-party analysis put it. Second, the Terminal-Bench pair cannot be subtracted at all: Clover reports version 2.1 at 51.7, while Qwen's official card reports version 2.0 at 51.5 — different versions, so subtracting them is meaningless. And the general warning: every figure comes from the vendor's own launch blog, which does not give enough detail for outsiders to reproduce the evaluations; the fine-tuning code is still marked coming soon. What can be verified today is the license and the files; what cannot yet be verified is the scores. The right posture for a Preview is to treat it as a downloadable, testable claim, not an established conclusion.

4. Deployment and boundaries: 69GB of weights, SGLang first, what Preview means

The deployment math first: BF16 weights of about 69GB mean a single roughly-90GB card or a quantized build — not a laptop download. There are three inference paths, and the official ranking is explicit: the official SGLang implementation first, for serving and evaluation; the Hugging Face Transformers implementation requires trust_remote_code (Transformers 5.19.0, PyTorch 2.10 or later), and the vendor acknowledges small numerical differences from SGLang's kernels that can change generated text under identical settings — do not mix the two paths when comparing results; llama.cpp support uses self-speculative decoding, but its backend code is not in the repository yet, so do not schedule it as available.\n\nThe license is its most concrete selling point: Apache-2.0, with the model card noting that the upstream Apache license and copyright statement from the base model are preserved — the part enterprise legal teams will read before the scores. The boundaries are equally concrete: first, a text-only model, so do not plan multimodal use; second, the Preview label means long-task, real-developer-tool performance is unestablished, and the vendor itself says it plans further validation on broader real-world tasks; third, no API — which is exactly why this article is not a paid-site candidate: with no hostable endpoint, there is nothing to wrap, and the value sits in the mechanism and the downloadable weights.\n\nSelection in three tiers. Tier one, direct fits: researchers of diffusion decoding and anyone wanting to run a large open coding model locally — downloadable weights, a friendly license, and a clear SGLang path make it worth pulling down to reproduce the vendor numbers. Tier two, usable with self-testing: teams wiring Clover into agentic coding pipelines — run sampled SWE-bench-style checks and long-task stress tests on your own task set first, and do not take 73.6 as your expected score. Tier three, hold off: scenarios needing stable production output, multimodality, or a hosted API — Preview plus no API plus unreproduced evaluations do not add up to a production choice.

5. Sources and disclaimer

Sources (verified November 1, 2026):\n1) https://huggingface.co/blog/Diffuspace/clover-35b-a3b-preview — official launch blog: 35B total parameters, about 3B active, thinking mode, SWE-bench 73.6, Terminal-Bench 2.1 51.7, τ³ 65.3, GPQA 83.8, ZebraLogic 95.8, AA-LCR 72.0, 680 tokens/s on one GB300, Apache license, SGLang and llama.cpp support;\n2) https://huggingface.co/Diffuspace/Clover-35B-A3B-Preview — official model card: 128K context (131,072 tokens), 40 layers, 256 experts with top-8 routing plus one shared expert, Gated DeltaNet / full-attention backbone, block_size=32, threshold 0.95, trust_remote_code, SGLang recommended;\n3) https://siliconnoon.com/deep-dive-clover-35b-a-diffusion-llm-at-qwen-parity-680-toks/ — third-party deep dive: about 69GB BF16 weights, the 0.2-point SWE-bench margin and its method gap, Terminal-Bench 2.1 vs 2.0 not subtractable, fine-tuning code coming soon;\n4) https://neuralbrew.ai/en/articles/2026/10/clover-35b-a3b-diffuspace-open-source-diffusion-language-model/ — October 28 release, H200 515 vs Qwen + DFlash2 365, six-agent-benchmark comparison basis;\n5) https://www.neuraldaily.news/en/a/diffuspace-clover-35b-open-diffusion-language-model — llama.cpp backend code not yet in the repository, Hugging Face vs SGLang numerical differences, about 69GB of GPU memory.\n\nDisclaimer: this site is not affiliated with DiffuSpace. This article is product-technology reporting and analysis, not procurement, deployment, or investment advice. Scores and speed figures are vendor-reported, marked preliminary, and not yet independently reproduced; deployment and license details follow official pages and may change.

Clover vs same-size autoregressive Qwen3.6-35B-A3B (vendor-reported figures, preliminary)

Dimension	Clover-35B-A3B-Preview	Qwen3.6-35B-A3B
Generation	Block diffusion: 32-token blocks rewritten in parallel	Autoregressive: one token at a time
Total / active params	35B / about 3B	35B / about 3B (same backbone)
Context	128K (131,072 tokens, prompt plus generation combined)	Similar scale (per official card)
SWE-bench Verified	73.6 (vendor-reported)	73.4 (vendor-published; different methods, the 0.2-point edge is not a settled win)
Terminal-Bench	51.7 (version 2.1)	51.5 (version 2.0; different versions, cannot be subtracted)
Speed basis	680 tokens/s on one GB300 (vendor internal workloads)	365 tokens/s on H200 with DFlash2 (vendor comparison basis)
License and access	Apache-2.0, open weights and code, no API	Apache-2.0-family license, per official card

Generation speed in tokens/s (vendor-reported internal workloads; different cards, order-of-magnitude reference only)

★ Clover (GB300)680 tokens/s

Clover (H200)515 tokens/s

Qwen + DFlash2 (H200)365 tokens/s

数据来源：Sources: DiffuSpace launch blog figures (one GB300, BF16, batch 1, internal agent workloads; H200 comparison on the vendor's basis); no independent reproduction, and the cards differ — do not read this as a same-card test

Frequently Asked Questions

How does a diffusion language model differ from an ordinary one?

An ordinary autoregressive model generates one token at a time: write a word, feed it back, write the next. A diffusion model starts with a whole block of blanks (Clover's default is 32 tokens per block) and revises it over several parallel passes, filling high-confidence positions at once, with a default threshold of 0.95. Words in the same block can consult each other, which is where the parallel speedup comes from.

Can Clover's 680 tokens/s be reproduced?

Not yet. It is DiffuSpace's own figure on a single GB300 (BF16, batch size 1, internal agent workloads), with no independent reproduction, and the launch blog does not give enough detail for outsiders to reproduce the evaluations. Treat it as a testable claim: the weights are downloadable, so pulling them down and running them is the verification.

What does local Clover deployment need?

BF16 weights of about 69GB, aimed at a single roughly-90GB card or a quantized build. The official SGLang implementation is recommended for serving and evaluation; the Hugging Face path needs trust_remote_code and can differ numerically from SGLang, so do not mix the two paths when comparing. The llama.cpp self-speculative decoding backend code is not in the repository yet.

Why is Clover not a paid-site candidate?

Because it has no API: weights and code are open on Hugging Face and GitHub, and anyone can download them directly, so there is no hostable endpoint to wrap. Its value is the block-parallel diffusion mechanism itself and the verifiable open weights, not a chargeable service entry point.