LLaDA2.2-Flash: Ant Group's Open-Source Diffusion Agent

LLaDA2.2-flash is InclusionAI's third diffusion-model generation in seven months. LLaDA2.0 launched in November 2025, described by the team as the first time a diffusion language model had been scaled to the 100-billion-parameter level. LLaDA2.1 followed in February 2026, focused on token-editing acceleration and shipping a Confidence-Aware Parallel (CAP) decoding mode that InclusionAI says reached 535 tokens per second. LLaDA2.2, released this month, is the first version aimed at agentic workloads rather than raw chat or code completion.

Each generation has arrived with model documentation, open weights and a technical report. That gives developers more to inspect than a product demonstration alone, although independent evaluation of LLaDA2.2 is still missing.

Most widely used models, including Claude, GPT, Gemini, Grok and Llama, are autoregressive: they predict the next token from everything that came before it, one token at a time, from left to right. That is reliable and easy to reason about, but it is inherently sequential: token 500 cannot be generated until token 499 exists.

Diffusion language models take a different approach, borrowed conceptually from image diffusion models like Stable Diffusion. Generation starts from a sequence that is entirely masked or noised, and the model iteratively “denoises” many positions at once across a fixed number of steps, refining the whole sequence in parallel rather than token-by-token. We covered the first commercially prominent example of this approach in our Mercury 2 review, which hits roughly 1,000 tokens per second using the same underlying principle from Inception Labs.

The trade-off is consistent across every diffusion LLM released so far: much higher throughput and better hardware utilisation, at some cost to the kind of careful, sequential multi-step reasoning that autoregressive models handle well. Classic diffusion LLMs also had a specific structural limitation that LLaDA2.2 is aimed directly at: once the output length is fixed at the start of generation, the model can fill in blanks, but it cannot lengthen or shorten the sequence, insert a missed step, or delete a wrong one, all of which matter enormously for an agent running a multi-turn tool-use loop where the right response length isn't known in advance.

LLaDA2.2's answer to that fixed-length problem is what InclusionAI calls Levenshtein Editing, named after the classic Levenshtein (edit) distance algorithm used to measure how many insertions, deletions and substitutions turn one string into another. The model's vocabulary gains two new control tokens, DELETE and INSERT, alongside the usual KEEP and SUBSTITUTE operations every masked-diffusion model already uses.

The worked example in InclusionAI's model card shows the practical effect. Starting from a garbled draft (“No man step step in the the river twice”), the model does not have to accept the wrong word count baked in from the start: at step t, it substitutes one “step” for “ever”, marks a duplicated “the” for deletion, and marks a gap for insertion. By step t+2 it has produced the grammatically correct target sentence, having changed the token count of the sequence mid-generation. A fixed-length masked-diffusion decoder cannot do that.

Training happens in three stages, each using Levenshtein Editing: continued pretraining on long-context and agent trajectory data, supervised fine-tuning on the same data mix, and then a reinforcement-learning stage InclusionAI calls L-EBPO (their Levenshtein-Edit-aware policy optimisation), run against a sandboxed agentic runtime that exposes real tasks, tool scaffolds and environments and scores the model on the rewards it earns. That last stage is what actually teaches the model to use edit operations usefully in live tool-calling loops, rather than just recognising them exist.

LLaDA2.2-flash is a mixture-of-experts model with 100 billion total parameters (non-embedding), organised into 32 layers with 32 attention heads, a 157,184-token vocabulary and Rotary Position Embeddings (RoPE). It supports a 128K-token context window, weights are published in both F32 and BF16 precision, and the model is available in two sizes: a 16B variant for lighter deployment and the 100B “flash” variant benchmarked in this piece.

The second architectural addition alongside Levenshtein Editing is Block Routing, which bounds mixture-of-experts activation at the level of each diffusion block rather than per-token. In a standard MoE transformer, a router decides which experts handle each token independently; in a diffusion model generating dozens of tokens per denoising step, doing that per-token would fragment expert utilisation and blow up memory bandwidth at long context lengths. Block Routing keeps expert selection consistent across a whole block of the sequence being denoised together, which is what InclusionAI credits for keeping the 128K-context agentic workloads computationally tractable at 100B scale.

InclusionAI's own model card compares LLaDA2.2-flash against Ling-2.6-flash (their own prior autoregressive-style flash model) across seven agent-relevant benchmarks: SWE-bench Verified, SWE-bench Pro, SWE-bench Multilingual, τ²-Bench (a tool-use/agent benchmark), MCP-Atlas, PinchBench and Claw-Eval. The published comparison is mixed:

• LLaDA2.2-flash trails on SWE-bench Verified (49.28 vs 61.20), SWE-bench Pro (30.10 vs 31.88), SWE-bench Multilingual (25.00 vs 33.73) and BFCL-v4 (60.78 vs 66.81).
• LLaDA2.2-flash leads on τ²-Bench (80.33 vs 76.36), MCP-Atlas (46.21 vs 41.12) and PinchBench (81.66 vs 81.30), and roughly ties on Claw-Eval (64.22 vs 64.56).

The pattern is coherent once you notice it: LLaDA2.2-flash is comparatively weaker on the software-engineering benchmarks that reward long, carefully sequenced reasoning (the SWE-bench family), and comparatively stronger on the benchmarks that specifically test tool-calling, multi-turn agent interaction and protocol handling (τ²-Bench, MCP-Atlas). The split is consistent with a model designed around mid-generation editing for agent loops rather than a general reasoning upgrade. InclusionAI publishes the weaker results alongside the stronger ones.

One caveat worth stating plainly: these are InclusionAI's own reported numbers from their model card, using their own evaluation harness. At the time of writing, no independent benchmark provider such as Artificial Analysis, LMArena or Epoch AI has published a third-party reproduction of these specific figures. That does not make them false, InclusionAI has a track record of publishing reproducible technical reports for LLaDA2.0 and 2.1, but it does mean the numbers above should be read as vendor-reported until independently confirmed, the same standard this site applies to any lab's first-party benchmark claims.

If the accuracy story is mixed, the throughput story is where LLaDA2.2-flash is unambiguous. Measured in tokens generated per second on the same five benchmark tasks, InclusionAI reports:

• SWE-bench Verified: 519.0 vs 303.2 tokens/sec (1.71x)
• SWE-bench Pro: 485.3 vs 283.4 tokens/sec (1.71x)
• SWE-bench Multilingual: 459.5 vs 200.6 tokens/sec (2.29x)
• τ²-Bench: 592.8 vs 334.9 tokens/sec (1.77x)
• BFCL-v4: 703.82 vs 331.5 tokens/sec (2.12x)

That is a consistent 1.7x–2.3x throughput advantage over Ling-2.6-flash on every single benchmark tested, including the ones where LLaDA2.2-flash's accuracy trails. For long tool-calling loops, such as multi-step research, coding task queues and customer-support conversations, wall-clock latency and serving cost can matter as much as raw accuracy. Throughput is the release's clearest advantage.

LLaDA2.2's own model card does not re-publish general knowledge and coding benchmarks (MMLU-Pro, HumanEval, AIME) already established by its predecessor, so the most honest way to size up the underlying LLaDA2 family's general capability is InclusionAI's original LLaDA2.0-flash comparison, published on the project's GitHub repository against LLaDA2.0-flash-preview, Ling-flash-2.0 and Alibaba's Qwen3-30B-A3B-Instruct-2507.

On that earlier comparison, LLaDA2.0-flash scored competitively against Qwen3-30B-A3B-Instruct-2507 and Ling-flash-2.0 on HumanEval (94.5), AIME 2025 (60.0) and Spider (82.5), while trailing Ling-flash-2.0 on raw MMLU-Pro (73.4 vs 76.8) and LiveCodeBench v6 (42.3 vs 44.1). That is broadly consistent with the pattern seen again in LLaDA2.2: a genuinely competitive general-purpose model, not a clean leader across every axis, with its actual differentiation coming from decoding speed and, now, agentic editing rather than raw benchmark supremacy.

The 100B LLaDA2.2-flash checkpoint is published on Hugging Face under the Apache 2.0 licence. Earlier LLaDA2 releases include 16B checkpoints. Apache 2.0 is one of the most permissive open-source licences available: it allows commercial use, modification and redistribution without the field-of-use or revenue-threshold restrictions that some other “open” model releases attach.

InclusionAI also publishes a custom inference stack built on dInfer and SGLang, supporting KV-cache reuse and block-level parallel decoding, alongside a full technical report on GitHub. Running the 100B checkpoint at the reported throughput requires multi-GPU serving infrastructure rather than consumer hardware. Teams seeking a smaller model can examine the earlier 16B LLaDA2 checkpoints, but they are not equivalent to LLaDA2.2-flash.

InclusionAI is the AI research team inside Ant Group, the fintech affiliate of Alibaba best known outside China for Alipay. Ant Group has spent 2025 and 2026 building out a serious independent model research effort, of which the Ling and LLaDA2 lines are the public output; Ling-2.6-flash, the comparison model used throughout LLaDA2.2's own benchmarks, is Ant Group's own prior autoregressive flash model rather than a competitor's.

That matters for reading the benchmark comparison correctly: this is not an independent third party pitting LLaDA2.2 against a rival lab's model, it is InclusionAI comparing its own new diffusion architecture against its own previous autoregressive one, which is a reasonable and common way for a lab to demonstrate an architectural trade-off, but is a different exercise from an independently adjudicated leaderboard placement.

LLaDA2.2-flash lands in the same week as a much louder story: Moonshot AI's Kimi K3 open-weight release, which has drawn both intense developer interest and a US export-control dispute over the Nvidia hardware used to train it. Zhipu's GLM line, Alibaba's Qwen family and DeepSeek V4 have all shipped major open-weight releases within weeks of each other this summer, and InclusionAI's LLaDA2.2 is a quieter addition to the same pattern: China's major labs are treating full open-weight releases, complete with technical reports and permissive licences, as a standard competitive move rather than an exception.

What makes LLaDA2.2 distinct within that pattern is architecture rather than headline benchmark scores: it is the only major release this summer built on discrete diffusion rather than an autoregressive transformer, at a scale (100B) that InclusionAI says is the first time that architecture family has been pushed this far. Whether diffusion architectures become a genuine third path alongside autoregressive transformers and hybrid state-space models, or remain a speed-optimised niche the way Mercury 2 has so far, is a real open question the next 12 months of releases will help answer.

Against Mercury 2, the other prominent diffusion LLM covered on this site, LLaDA2.2-flash is the more agent-oriented of the two: Mercury 2's pitch is raw single-shot throughput (roughly 1,000 tokens/sec) for code completion and high-volume document processing, while LLaDA2.2 trades some of that peak speed for the Levenshtein Editing mechanism aimed specifically at multi-turn tool-calling loops. Neither is API-gated behind a single vendor: Mercury 2 is proprietary-but-API-accessible from Inception Labs, while LLaDA2.2 is fully open-weight.

Compared with current Chinese open-weight autoregressive models such as Kimi K3, DeepSeek V4 and Qwen 3.8 Max, LLaDA2.2-flash is not a frontier-accuracy contender; its own benchmark chart shows it trailing on several standard coding and tool-use tests. Its case for attention is architectural and economic: a genuinely different generation mechanism, released with full weights, that delivers meaningfully lower latency per task for agent workloads specifically, at a moment when agent-loop serving cost is becoming as important a competitive axis as raw leaderboard position.

• Accuracy trade-offs are real, not marketing spin, and are worse than the comparison model on the SWE-bench family and BFCL-v4 specifically.
• All benchmark numbers are vendor-reported. No independent lab reproduction was available at the time of writing.
• Serving the 100B checkpoint requires real infrastructure. This is not a model you self-host casually; multi-GPU deployment via dInfer/SGLang is the documented path.
• No third-party safety evaluation has been published alongside the model card; InclusionAI's technical report focuses on capability and throughput rather than red-teaming or misuse evaluation.
• Ecosystem tooling is younger than for mainstream autoregressive open-weight models; expect rougher edges in existing agent frameworks that assume token-by-token generation.

Teams running high-volume, latency-sensitive agent loops, including customer-support agents, research agents and batch agentic pipelines, are the clearest fit, provided they have the GPU infrastructure to serve a 100B MoE model. Researchers studying diffusion language models now have a second serious open-weight agentic diffusion model to study alongside Mercury 2's proprietary approach, with full training code available. Teams whose workloads are dominated by complex, sequential coding tasks (the SWE-bench profile) should not expect LLaDA2.2-flash to beat their current autoregressive model on accuracy; the case here is latency and cost, not a capability upgrade.

LLaDA2.2-flash is an open-weight release with an Apache 2.0 licence, a technical report and a clear architectural design built around Levenshtein Editing and Block Routing. It is not a frontier-beating model on accuracy, and InclusionAI's own numbers say so plainly. On the evidence currently available, it is a substantial attempt to apply diffusion language models to agent workloads at 100B scale. The reported throughput advantage is consistent enough to warrant independent testing, but deployment-cost claims need measurements beyond the vendor's evaluation.

The number worth watching next is not a benchmark score: it is whether an independent evaluator reproduces InclusionAI's figures, and whether real agent frameworks add first-class support for Levenshtein Editing rather than treating LLaDA2.2 as just another OpenAI-compatible chat endpoint.

• InclusionAI, LLaDA2.2-flash model card, Hugging Face, July 2026.
• InclusionAI, LLaDA2.X GitHub repository, including the LLaDA2.2 technical report and LLaDA2.0-flash benchmark chart.
• InclusionAI, LLaDA2.0-flash model card, Hugging Face, November 2025.
• InclusionAI, LLaDA2.1-flash model card, Hugging Face, February 2026.