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

LLaDA2.2-flash is a discrete diffusion language model, the third release in InclusionAI's LLaDA2 series and the first built specifically for agents. It introduces Levenshtein Editing, a mechanism that adds DELETE and INSERT control tokens to the model's vocabulary so it can restructure a sequence — not just fill in blanks — while generating in parallel.

• Published: July 2026, on Hugging Face and GitHub, Apache 2.0 licence, both 16B and 100B checkpoints.
• Architecture: 100B total parameters (non-embedding), mixture-of-experts, 32 layers, 32 attention heads, 128K context, RoPE positional encoding.
• Headline capability: Block Routing, which bounds expert activation per diffusion block, keeping long-context agent workloads efficient.
• Verified result: 1.7x–2.3x higher tokens-per-second throughput than Ling-2.6-flash across five agentic benchmarks, with mixed (not uniformly better) accuracy.
• Not yet independently verified: these are InclusionAI's own reported numbers; no third-party lab such as Artificial Analysis has published a reproduction at the time of writing.

LLaDA2.2-flash is not InclusionAI's first diffusion model, it is the third 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 come with a full technical report and open weights rather than a blog post and a demo, which is a meaningfully different disclosure standard from the marketing-driven “agent OS” product videos currently circulating on AI YouTube. Whatever you make of the model itself, the paper trail here is real: model cards, a GitHub repository, and a downloadable technical report for each release.

Almost every model most readers use day to day — Claude, GPT, Gemini, Grok, Llama — is autoregressive: it predicts the next token conditioned on every token that came before it, one at a time, 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 own model card is genuinely useful for understanding what this buys you. 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 — something a fixed-length masked-diffusion decoder structurally cannot do.

Training happens in three stages, each explicitly built “with Levenshtein Editing” baked in from the start rather than bolted on afterward: 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 chart at the top of this article is that comparison in full, and it is a genuinely mixed picture rather than a clean win:

• 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). That is exactly the kind of split you would expect from a model whose headline feature is a mid-generation editing mechanism aimed at agent loops rather than a general reasoning upgrade, and InclusionAI does not appear to have tried to obscure it — the losses are printed on the same chart as the wins.

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 agent workloads that run long tool-calling loops — multi-step research agents, coding agents that iterate on a task queue, customer-support agents holding long conversations — wall-clock latency and serving cost per task often matter as much as raw accuracy, and this is the number InclusionAI is clearly optimising the whole release around.

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.

Both the 16B and 100B LLaDA2.2 checkpoints are published on Hugging Face under the Apache 2.0 licence, InclusionAI's standard choice across the whole LLaDA2 series. 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 throughput numbers reported above requires multi-GPU serving infrastructure comparable to any other 100B-class mixture-of-experts model, not consumer hardware; the 16B variant is the more realistic option for smaller-scale self-hosting.

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.

Against the current wave of open-weight Chinese autoregressive models — Kimi K3, DeepSeek V4, 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 — think customer-support agents, research agents iterating over long tool-call chains, or 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 a genuine, verifiable open-source release: real weights, a real technical report, a permissive licence and a coherent architectural story built around Levenshtein Editing and Block Routing. It is not a frontier-beating model on accuracy, and InclusionAI's own numbers say so plainly. What it is, on the evidence currently available, is the most serious attempt yet to make diffusion language models genuinely useful for agent workloads specifically, at a scale nobody has previously shipped that architecture at, with a throughput advantage that is consistent and large enough to matter for real deployment costs.

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.