Verdict: LLaDA 2.2-Flash is the fastest open-source model purpose-built for AI agent workloads available in 2026. Released in July 2026 by Ant Group's InclusionAI team under the Apache 2.0 license, this 100-billion-parameter diffusion language model generates text at over 700 tokens per second on tool-use benchmarks — roughly 1.7× to 2.3× faster than Ling-2.6-flash, a comparable autoregressive model. Its standout innovation, Levenshtein Editing, lets it delete and insert tokens mid-generation, fixing its own mistakes before finishing a response. It is not the most accurate open model on every benchmark, but for builders running multi-step agent loops where speed and self-correction matter more than peak accuracy, it is the most compelling open-weight option available right now.
Last verified: 2026-07-30
- What it is: 100B-parameter MoE diffusion language model for agentic workloads, from Ant Group's InclusionAI team
- License: Apache 2.0 (full weights on Hugging Face and GitHub) — commercial use allowed
- Key innovation: Levenshtein Editing (DELETE + INSERT control tokens for mid-generation self-correction)
- Speed: 703.82 tokens/sec on BFCL-V4 tool-use benchmark; 1.7×–2.3× faster than Ling-2.6-flash across five agentic benchmarks
- Context window: 128K tokens
- Best for: Builders running multi-step AI agents where wall-clock speed and error recovery matter
- Not for: Casual chatbot use; you need real GPU infrastructure (100B parameters, ~205 GB VRAM)
- Volatile facts: Benchmark scores and speeds are vendor-reported (InclusionAI); no independent third-party reproduction available as of July 2026
How is LLaDA 2.2-Flash different from models like GPT, Claude, or Llama?
Almost every language model you use daily — GPT, Claude, Gemini, Llama — is autoregressive. It generates text one token at a time, left to right, and each new word depends on everything that came before it. Token 500 cannot exist until token 499 is written. This sequential approach is reliable, but it puts a hard ceiling on how fast text generation can go.
LLaDA 2.2-Flash is a diffusion language model. Instead of writing one word at a time, it starts with a fully masked (noised) sequence and refines many positions simultaneously across multiple denoising steps. Think of it like a photo loading on a slow connection: blurry at first, then progressively sharper with each pass, until the full image resolves. This parallel refinement is what makes it dramatically faster than autoregressive models of comparable size (InclusionAI, LLaDA2.2-flash model card, Hugging Face, July 2026).
But LLaDA 2.2-Flash adds something diffusion LLMs could not do before: Levenshtein Editing. Previous diffusion language models could only fill in masked blanks — they could not change the length of the sequence mid-generation. LLaDA 2.2-Flash adds two special control tokens, DELETE and INSERT, so the model can rip out a wrong chunk and slot in something better while it is still generating. This is the "catching its own mistakes while writing" capability. An autoregressive model that writes a bad token at position 200 is stuck with it for the rest of the response. LLaDA 2.2-Flash can go back and fix it (InclusionAI, LLaDA2.2 technical report, GitHub, July 2026).
What is Levenshtein Editing and why does it matter for agents?
Levenshtein Editing is the core innovation that makes LLaDA 2.2-Flash specifically suited for agent workloads, not just chat. Here is what it is and why it changes the math for builders.
Standard diffusion LLMs work by filling in masked positions in a sequence. The sequence length is fixed at the start — if the model guesses too many or too few positions, it cannot restructure. LLaDA 2.2-Flash breaks this constraint by introducing DELETE and INSERT control tokens into its vocabulary. During generation, the model can:
- DELETE a token it realizes is wrong or redundant
- INSERT a new token into a gap it identifies needs filling
- Restructure the sequence length while it is still being refined — something no fixed-length diffusion decoder can do
The InclusionAI team trained this capability using a method called Levenshtein Editing ELBO-based Block-level Policy Optimization (L-EBPO), which uses rewards from agentic environments (tool-use tasks, multi-turn interactions) to teach the model when and how to edit itself (InclusionAI, LLaDA2.2-flash model card, Hugging Face).
Why this matters for agents specifically: When an AI agent uses tools, takes multiple steps, and goes back and forth, it will inevitably slip up somewhere in the chain. A standard autoregressive model plows forward with the mistake baked in — the error compounds through subsequent steps until the whole thing falls apart on step four and you have to start over. LLaDA 2.2-Flash can spot the error and fix it midstream, which means fewer broken tool-call chains and fewer total failures per agent run. If you are building agents that need to complete long multi-step workflows reliably, this self-correction capability is the real selling point — not just the speed.
How fast is LLaDA 2.2-Flash compared to other open-source models?
LLaDA 2.2-Flash was measured at 703.82 tokens per second on the BFCL-V4 tool-use benchmark, its fastest reported result. On InclusionAI's own benchmarks, it generates tokens 1.7× to 2.3× faster than Ling-2.6-flash, a comparable autoregressive model, across five agentic benchmark tasks (InclusionAI, LLaDA2.2-flash model card, Hugging Face):
| Benchmark | LLaDA 2.2-Flash (TPS) | Ling-2.6-flash (TPS) | Speed advantage |
|---|---|---|---|
| SWE-bench Verified | 519.0 | 303.2 | 1.71× |
| SWE-bench Pro | 485.3 | 283.4 | 1.71× |
| SWE-bench Multilingual | 459.5 | 200.6 | 2.29× |
| τ²-Bench | 592.8 | 334.9 | 1.77× |
| BFCL-V4 | 703.82 | 331.5 | 2.12× |
Important caveat: These are InclusionAI's own reported numbers from their model card. No third-party lab (such as Artificial Analysis or LMSYS) has published an independent reproduction as of late July 2026. Treat them as vendor-reported until independently confirmed. The throughput advantage is consistent across every benchmark tested — even the ones where LLaDA 2.2-Flash trails on accuracy — which suggests the speed gain is architectural (diffusion's parallel decoding), not cherry-picked.
For context, LLaDA 2.0-flash, the predecessor released in November 2025, already reached 535 tokens/second using Confidence-Aware Parallel (CAP) decoding (InclusionAI, LLaDA2.0-flash, AIBase, December 2025). The 2.2 version pushes past 700 tokens/second on tool-use workloads.
If you are comparing diffusion vs. autoregressive approaches more broadly, the speed gap is even larger on cheaper hardware: community benchmarks of DiffusionGemma 26B on an RTX 4090 show ~180 tokens/sec vs. ~50 tokens/sec for the autoregressive Gemma 2 27B — a 3.6× advantage (DiffRun benchmarks, 2026).
How accurate is LLaDA 2.2-Flash on agent benchmarks?
The accuracy story is mixed. LLaDA 2.2-Flash does not win on every benchmark — it is a throughput-first trade, not a strict accuracy upgrade. Here are the scores InclusionAI reported head-to-head against Ling-2.6-flash (InclusionAI, LLaDA2.2-flash model card, Hugging Face):
| Benchmark | LLaDA 2.2-Flash | Ling-2.6-flash | Winner |
|---|---|---|---|
| SWE-bench Verified | 49.28 | 61.20 | Ling-2.6-flash |
| SWE-bench Pro | 30.10 | 31.88 | Ling-2.6-flash |
| SWE-bench Multilingual | 25.00 | 33.73 | Ling-2.6-flash |
| τ²-Bench | 80.33 | 76.36 | LLaDA 2.2-Flash |
| Claw-Eval | 64.22 | 64.56 | Ling-2.6-flash |
| PinchBench | 81.66 | 81.30 | LLaDA 2.2-Flash |
| MCP-Atlas | 46.21 | 41.12 | LLaDA 2.2-Flash |
| BFCL-V4 | 60.78 | 66.81 | Ling-2.6-flash |
The pattern is clear: LLaDA 2.2-Flash trails on coding benchmarks (SWE-bench series) and the BFCL-V4 function-calling test, but leads on multi-turn agent interaction benchmarks (τ²-Bench, MCP-Atlas, PinchBench). This aligns with InclusionAI's positioning: the model is built for agentic workloads (multi-step tool use, long conversations, error recovery) rather than pure code generation.
In plain terms: if you need the best coding agent, look at autoregressive models or the broader open-source landscape (GLM-5.1, Kimi K2.6 — see our guide to open weight vs. closed AI models). If you need an agent that takes many steps, uses tools, runs fast, and fixes its own mistakes along the way, LLaDA 2.2-Flash is the one designed for that job.
What is Block Routing and why does it matter at 128K context?
LLaDA 2.2-Flash uses a Mixture-of-Experts (MoE) architecture: it has many specialized sub-networks ("experts") and routes each piece of work to the most relevant ones. At 100 billion total parameters with a 128K-token context window, keeping this routing efficient is a real engineering challenge.
Block Routing is InclusionAI's solution. In a standard MoE transformer, the router selects experts independently for each token. But in a diffusion model generating dozens of tokens per denoising step, per-token routing would fragment expert utilization and blow up memory bandwidth at long context lengths. Block Routing instead keeps expert selection consistent across a whole block of the sequence being denoised together — grouping the routing decision at the diffusion-block level rather than per-token (InclusionAI, LLaDA2.2 technical report, GitHub).
The practical result: the model can handle up to 128,000 tokens of context (roughly a small book's worth) without losing efficiency. For agent workloads — where you might feed the model long conversation histories, multi-step tool-call traces, or large codebase context — this matters. A model that can hold a long context window in its head without degrading is essential for agents that need to maintain state across a complex workflow. For a deeper dive into multi-step agent orchestration, see our 5-layer framework for orchestrating AI agents like a company.
LLaDA 2.2-Flash model specifications
| Specification | Value |
|---|---|
| Model ID | inclusionAI/LLaDA2.2-flash |
| Architecture | MoE Diffusion Language Model with Levenshtein Editing |
| Total Parameters (non-embedding) | 100B |
| Context Length | 128K tokens |
| Layers | 32 |
| Attention Heads | 32 |
| Positional Encoding | RoPE (Rotary Position Embedding) |
| Vocabulary Size | 157,184 |
| Control Tokens | DELETE, INSERT |
| License | Apache 2.0 |
| Precision Available | F32, BF16 |
| Weights Size | ~205.79 GB |
| Source | Hugging Face model card |
How do you run LLaDA 2.2-Flash?
You can download the model weights right now from Hugging Face and ModelScope. Since it is Apache 2.0 licensed, there is no gate, no wait list, and no commercial-use restriction.
However, this is not a model that runs on a laptop. At ~205 GB of weights for the 100B checkpoint, you need real GPU infrastructure — multi-GPU serving similar to other 100B-class MoE models. InclusionAI publishes a custom inference stack built on dInfer and SGLang that supports KV-cache reuse and block-level parallel decoding. SGLang deployment support was listed as "coming soon" on the Hugging Face model card as of July 2026 (InclusionAI, LLaDA2.2-flash model card).
Here is the basic inference setup using Hugging Face Transformers:
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
model_path = "inclusionAI/LLaDA2.2-flash"
device = "auto"
model = AutoModelForCausalLM.from_pretrained(
model_path,
trust_remote_code=True,
torch_dtype=torch.bfloat16,
device_map=device
)
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
The recommended starting settings from the model card are: temperature=1.0, block_length=32, threshold=0.5, editing_threshold=0.0. The team explicitly recommends starting with these defaults and only tuning the speed-quality knobs once you understand what each does — pushing too hard toward speed can cause output repetition and instability.
For builders new to running open-source models at scale, our guide to 10 free open-source AI tools you can actually run covers the infrastructure stack and local deployment options.
The LLaDA 2 series: a brief lineage
LLaDA 2.2-Flash is not a one-off experiment — it is the third generation in seven months of sustained development from InclusionAI. Understanding the lineage helps you judge whether this is a direction worth investing in:
- LLaDA 2.0 (November 2025): The first diffusion language model scaled to 100 billion parameters. Featured MoE architecture with 16B (mini) and 100B (flash) variants. Introduced the Warmup-Stable-Decay pretraining strategy to inherit knowledge from existing autoregressive models. Reached 535 tokens/sec with CAP decoding (InclusionAI, GitHub).
- LLaDA 2.1 (February 2026): Focused on token-editing acceleration. Shipped Confidence-Aware Parallel (CAP) decoding mode. Improved speed but was still a masked-diffusion model — no sequence restructuring.
- LLaDA 2.2 (July 2026): The first version built specifically for agentic workloads. Added Levenshtein Editing (DELETE + INSERT control tokens), Block Routing for efficient 128K-context MoE inference, and L-EBPO training with agentic environmental rewards.
Each generation came with a full technical report and open weights — model cards, a GitHub repository, and a downloadable PDF for each release. This is a different disclosure standard from marketing-driven "agent OS" product videos. The paper trail is real and verifiable.
What does "diffusion language model" actually mean?
If you have only used models like GPT or Claude, the diffusion approach can feel counterintuitive. Here is the plain-language version:
An autoregressive model writes left to right, one token at a time. Each word is predicted based on everything that came before it. It is like typing with one finger — reliable, but inherently sequential.
A diffusion language model borrows the concept from image diffusion models (like Stable Diffusion). It starts with a sequence that is entirely masked or noised, then 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. Think of it like a photo loading: blurry at first, then progressively sharper, then done.
The key trade-off: diffusion models can generate text much faster (many positions at once vs. one at a time), but traditionally struggled with tasks requiring deep sequential reasoning and chain-of-thought logic. Autoregressive models still hold an edge for long reasoning chains because their left-to-right structure naturally supports step-by-step deduction. However, independent academic research in 2026 has shown diffusion language models can now match or exceed autoregressive models on tasks like translation and summarization while generating up to 5× faster (Diffusion Language Models: An Experimental Analysis, arXiv, 2026).
LLaDA 2.2-Flash's Levenshtein Editing is the innovation that starts closing the reasoning gap: by letting the model restructure its sequence mid-generation, it can self-correct errors that a fixed-length diffusion model would be stuck with — getting closer to the "think while writing" capability that makes autoregressive models good at reasoning.
For a broader comparison of why diffusion LLMs could be the fastest models available right now, see our analysis of the fastest AI model in 2026: diffusion LLM vs. ChatGPT.
Who is LLaDA 2.2-Flash actually for?
Not everyone needs this model. Here is an honest breakdown:
You need it if:
- You are building AI agents that perform multi-step workflows with tool calls — research agents, coding agents, customer support agents that carry long conversations
- Wall-clock speed matters for your use case (running 100 tiny steps in a row, latency-sensitive user-facing agents, cost-per-task optimization)
- You want self-correcting behavior baked into the model rather than building external retry/error-handling logic
- You need the full open-weight Apache 2.0 license for commercial use
- You have (or can rent) multi-GPU infrastructure for a 100B model
You do not need it if:
- You just want to chat with an AI and ask questions — the popular closed models (GPT, Claude, Gemini) are better tuned for that and require no infrastructure
- You need the highest coding accuracy specifically — autoregressive models like GLM-5.1 or Kimi K2.6 score better on SWE-bench
- You are running on consumer hardware with limited GPU memory — 205 GB of weights is not something a single GPU can hold
- You need the model live in production today with full framework support — SGLang deployment was still listed as "coming soon" on the model card as of July 2026
Speed is not just a comfort thing for agent builders. If your agent takes 100 sequential tool-call steps, a model that is twice as fast does not just feel nicer — it changes what is worth building. Workflows that were too slow to be practical suddenly fit into a reasonable time window. That is the part most people miss about LLaDA 2.2-Flash: the speed advantage does not just improve your existing agents, it unlocks agent ideas that were previously too slow to ship.
What this means for you
If you are a developer, builder, or small business owner using AI for real work, LLaDA 2.2-Flash signals a shift worth watching. Diffusion language models are no longer a research curiosity — at 100B parameters with full open weights, agent-specific capabilities, and 700+ tokens/sec throughput, this is the first model that makes the diffusion architecture genuinely deployable for agent workloads.
Your action items:
- If you are building agents today, add LLaDA 2.2-Flash to your evaluation shortlist — particularly if speed or self-correction on multi-step tasks is a bottleneck.
- Budget for infrastructure: you need multi-GPU serving, not a laptop. If that is a barrier, look at the 16B variant (LLaDA 2.0-mini) for lighter deployments.
- Start with the recommended defaults (temperature=1.0, block_length=32, threshold=0.5) before tuning. The speed-quality trade-off is real; pushing speed too hard causes repetition.
- Watch for independent benchmark reproduction — if a third-party lab confirms InclusionAI's throughput numbers, this model becomes a much safer bet for production.
- Track whether agent frameworks add first-class support for Levenshtein Editing. Right now, most frameworks would treat LLaDA 2.2 as just another OpenAI-compatible chat endpoint, which means you would not get the full self-correction benefit. Native integration is what unlocks the real value.
The broader signal: the open-source AI race is no longer just about matching closed models on accuracy benchmarks. It is about architectures purpose-built for specific workloads — and for agents, the diffusion approach is proving it can do something autoregressive models structurally cannot: write fast, go back, and fix itself mid-sentence.
FAQ
Q: What is LLaDA 2.2-Flash? A: LLaDA 2.2-Flash is a 100-billion-parameter open-source diffusion language model from Ant Group's InclusionAI team, released in July 2026 under the Apache 2.0 license. It is the first model in the LLaDA 2 series built specifically for agentic workloads, using a technique called Levenshtein Editing to insert and delete tokens mid-generation.
Q: How fast is LLaDA 2.2-Flash? A: On InclusionAI's own benchmarks, LLaDA 2.2-Flash generates 459–704 tokens per second across five agentic benchmark tasks, which is 1.7× to 2.3× faster than the comparable Ling-2.6-flash model. Its fastest result was 703.82 tokens/sec on the BFCL-V4 tool-use benchmark. These are vendor-reported numbers not yet independently verified.
Q: How is a diffusion language model different from a regular LLM? A: Regular LLMs (GPT, Claude, Llama) are autoregressive — they generate one token at a time, left to right. Diffusion language models start with a fully masked sequence and denoise many positions at once across multiple steps, enabling parallel generation and much higher throughput. The trade-off is that diffusion models have historically been weaker on long sequential reasoning.
Q: What is Levenshtein Editing and why does it matter? A: Levenshtein Editing adds DELETE and INSERT control tokens to a diffusion language model's vocabulary, letting it restructure a sequence mid-generation — removing wrong tokens and adding new ones during parallel decoding. This gives the model self-correction capability that fixed-length masked-diffusion models lack, which is critical for multi-step agent workflows where errors compound across steps.
Q: Can I run LLaDA 2.2-Flash on my laptop? A: No. The 100B checkpoint requires approximately 205 GB of VRAM, making it a multi-GPU serving workload. You need either your own multi-GPU setup or a cloud GPU service. A 16B variant (LLaDA 2.0-mini) is available for lighter deployments if hardware is a constraint.
Q: Is LLaDA 2.2-Flash free for commercial use? A: Yes. The model is released under the Apache 2.0 license on Hugging Face, which permits commercial use, modification, and redistribution without field-of-use or revenue-threshold restrictions. You can download the weights from huggingface.co/inclusionAI/LLaDA2.2-flash.
Q: Is LLaDA 2.2-Flash the most accurate open-source agent model? A: No. On InclusionAI's own benchmarks, it trails Ling-2.6-flash on several coding and function-calling benchmarks (SWE-bench Verified, BFCL-V4). It leads on multi-turn agent interaction benchmarks (τ²-Bench, MCP-Atlas, PinchBench). The model is a throughput-first trade — it sacrifices some peak accuracy for significantly faster generation and self-correction.
Discussion
0 comments