LLaDA2.X is Ant Group's diffusion language model series, scaled to 100B

A release repository, not a training repository

The repository description is short: LLaDA2.0 is the diffusion language model series developed by the InclusionAI team at Ant Group. The title expands the scope: LLaDA2.X, a series of large diffusion language models from LLaDA2.0 to LLaDA2.2 and onwards.

What is actually in the repository is worth knowing before you clone it. The top level holds a LICENSE, three technical report PDFs, a README.md and a figures directory. That is the entire content. The naming is LLaDA2_2_tech_report.pdf, llada2_1_tech_report.pdf and tech_report.pdf, the last of which is presumably the LLaDA2.0 report.

So the repository is a noticeboard, not a codebase. The substantive artefacts are the papers and the model weights, and the weights live on Hugging Face under the inclusionAI organisation, with separate collections for llada20, llada21 and llada22.

The related projects are linked from the readme as well: dFactory and dInfer, both under the inclusionAI organisation. The readme's deployment section names dInfer and SGLang as the basis of the inference engine, and dFactory appears as a separate repository link. So the training and serving work is split across sibling repositories, and this one is the place where the results and the papers are announced.

The licence is the Apache License 2.0, which is a notable choice for a model release and means the weights carry the same terms as the code.

Three releases, and the problem each one attacks

The what's new list gives the release history as three dated entries, and the dates matter because the series moved quickly.

The July 2026 release is LLaDA2.2, titled Enabling Agentic Diffusion Language Models via Levenshtein Editing. The February 2026 release is LLaDA2.1, titled Speeding Up Text Diffusion via Token Editing. And the November 2025 release is LLaDA2.0, described as the first diffusion language model scaled to 100B parameters, with a MoE architecture.

The pattern in the titles is worth reading on its own. 2.0 is about scale, 2.1 is about speed through token editing, and 2.2 is about agency through Levenshtein editing. A diffusion model generates by iteratively refining a sequence rather than by appending tokens left to right, and the interesting research question is how to make that refinement process produce text that is fast and that can be steered, since an agent needs to revise output rather than only extend it.

Levenshtein editing in that context is a distance measure between sequences, which is the natural tool for saying how far a draft is from a target rather than how many tokens have been emitted. The repository also links a figure of the decoding trajectory, the sequence of states a diffusion model passes through, which is the clearest visual explanation of how the approach differs from autoregressive generation.

The model variants table also shows how the naming has become slightly tangled across versions, with flash and mini variants and CAP versions appearing under both the 2.0 and 2.1 labels.

Seven checkpoints, and what CAP means

The variants table lists seven model identifiers, and the descriptions are consistent enough to be worth reading as a guide.

Five of them are instruction-tuned models ready for downstream applications: LLaDA2.2-flash, LLaDA2.1-mini, LLaDA2.1-flash, LLaDA2.0-mini and LLaDA2.0-flash. Two are the CAP variants, LLaDA2.0-mini-CAP and LLaDA2.0-flash-CAP, described as enhanced with Confidence-Aware Parallel for efficient inference.

So the naming has three axes: the series version, the size class of mini or flash, and an optional CAP suffix. Each row links to a model card on Hugging Face.

The size split is stated in the model introduction. The LLaDA2.0 family features LLaDA2.0-mini at 16B and LLaDA2.0-flash at 100B with a Mixture-of-Experts architecture, and it is described as the first time diffusion models have been scaled to the 100-billion parameter level.

The MoE detail is the one that makes a 100B model runnable at all, because the parameter count is the total across experts rather than the count of parameters active for any one token. A 16B mini model and a 100B MoE model are not the same kind of thing to serve, and the fact that both are published as open weights makes the smaller one the more practical starting point for most evaluations.

The parallel decoding claim, and the speed numbers

The key features list makes three claims, and the middle one is the one with numbers in it.

The first is scale: LLaDA2.0-flash is the largest diffusion language model to date, with exceptional performance on code generation and complex instruction-following tasks.

The second is the inference acceleration figure: 2.1x, from a parallel decoding mechanism, with LLaDA2.0-flash-CAP reaching an inference speed of up to 535 tokens/s, described as significantly outpacing comparable autoregressive models.

The third is that the model weights for both the 16B and 100B versions, along with the associated training code, are fully open-sourced on Hugging Face.

The relationship between the 2.1x figure and the CAP variants is the point to hold on to. The speed claim is attached to the CAP checkpoint specifically, and the CAP suffix means Confidence-Aware Parallel, so the acceleration comes from a decoding strategy that evaluates which positions can be resolved in parallel rather than refining them one at a time. That is the natural way to attack the slowest property of diffusion decoding, and it is why both a mini-CAP and a flash-CAP exist in the table alongside the standard checkpoints.

The evaluation results are presented as a figure rather than a table, so the readme does not give the per-benchmark numbers, and it points at a main benchmark chart for the flash model.

Deployment depends on a custom engine, not a standard one

The deployment section is short and it is the part that tells you whether this is deployable for you.

The stated approach is that to make the 100B model practical, deep engineering optimizations were performed. The team built a custom inference engine based on dInfer and SGLang, which supports KV-Cache reuse and block-level parallel decoding. The claim is that this makes LLaDA2.0 not just an academic achievement but a high-performance generation model ready for real-world deployment.

Two mechanisms are named, and both are worth understanding. KV-Cache reuse matters because a diffusion model revises a whole sequence rather than extending it, so the usual prefix caching story does not apply cleanly, and reusing cached state across refinement steps is where the savings are. Block-level parallel decoding is the mechanism behind the CAP approach, resolving independent regions of the sequence at the same time.

The consequence for an adopter is that this is not a model you point a standard serving stack at. You are taking a fork or a branch of dInfer and SGLang, and your deployment inherits whatever that stack does. For a research group that is the point, since the engine is where the paper's speed results live, and for a team shipping a product it is a dependency on infrastructure you do not control.

The model weights themselves, though, are ordinary Hugging Face artefacts, and the 16B mini variant in particular could be run on infrastructure you already have.

The citation entry points at two arXiv papers

The readme ends with a BibTeX block of two entries, and they are the formal record of the work.

The first is LLaDA2.1: Speeding Up Text Diffusion via Token Editing, from 2026, with the arXiv identifier 2602.08676 and the primary class cs.LG. The second is LLaDA2.0: Scaling Up Diffusion Language Models to 100B, from 2025, with the identifier 2512.15745 and the same primary class.

The author lists are long, which is what a large industrial research group looks like, and they include the Ant Group researchers behind the LLaDA line alongside academic co-authors.

The version numbering in the citations does not line up with the release dates in the what's new list, and the arXiv identifiers are dated accordingly. So the 2.0 paper with the 2025 identifier is the scale paper, and the 2.1 paper with the 2026 identifier is the token editing paper, while LLaDA2.2 and its Levenshtein editing work is documented separately in the technical report PDF that sits at the top of the repository rather than in a citation entry yet.

That is the pattern of a series in progress: two papers cited, a third report in the repository, and the naming in the model table already running ahead to the next version.

Editorial conclusion

Adopt LLaDA2.X if you are evaluating diffusion language models as an alternative to autoregressive ones and you want the open weights and the inference engine to look at, since the 100B variant and the parallel decoding work are the parts worth studying. Do not expect a training repository here, because the top level holds only the licence, three technical report PDFs, a figures directory and the readme, so anything you need for training has to come from the linked dFactory and dInfer repositories. Before you plan an evaluation, check three things: which of the seven published checkpoints matches your hardware, because the 100B flash model and the 16B mini model are very different propositions, whether the CAP variants or the standard ones suit your latency target, and which inference path you will use, since the engine is a custom build rather than a standard one.

Frequently asked questions

Official sources

1. inclusionAI/LLaDA2.X on GitHub
2. Issues
3. License: Apache-2.0
4. README