LLaDA2.2-mini: Ant inclusionAI's Diffusion Agent Weights Appeared Quietly on September 5

At 05:16 UTC on September 5, 2026, a Hugging Face repository named inclusionAI/LLaDA2.2-mini came into existence, and as of this writing that is almost the entire story of the release: weights are up, the model card is written, and the vendor — inclusionAI, the Ant Group lab behind the LLaDA diffusion-model line — has said nothing about it. No launch post, no social rollout, no entry in the inclusionAI/LLaDA2.X GitHub README's model table, where the larger LLaDA2.2-flash sits alone. Twenty-four hours after the repo appeared, its download counter read zero. This is a what-we-know-so-far piece about LLaDA2.2-mini, and the discipline of that format matters here, because almost every interesting number attached to the model is a number inclusionAI typed onto its own card. This article separates what is independently verifiable about the release from what is vendor-reported, and it names the open questions rather than smoothing over them.

The short version, for someone who just wants the shape of it: LLaDA2.2-mini is the small sibling of the LLaDA2.2-flash diffusion language model that inclusionAI announced in July 2026, now available as a 16-billion-parameter mixture-of-experts checkpoint that activates only 1.4 billion parameters per token, runs a 128K context, and is trained to do agentic work — tool calling, multi-turn correction — using a diffusion decoder that can insert and delete tokens mid-generation. It is Apache-2.0. And because the weights are one day old with no announcement behind them, none of the usual scaffolding exists yet: no independent evaluation, no hosted API we can find, no serving guides beyond what the card itself recommends. What you can verify today is the architecture, the license, and the numbers inclusionAI chose to publish.

The release is a repository, not an event

Start with what can be checked without trusting anybody. The Hugging Face API records inclusionAI/LLaDA2.2-mini as created on September 5, 2026, and last modified the same day. It is Apache-2.0 licensed, uses the safetensors format with bf16 tensors, carries a chat template, and requires trust_remote_code because the diffusion architecture ships as custom modeling code. The repo's sibling, inclusionAI/LLaDA2.2-flash, was created on July 16, 2026, has amassed thousands of downloads and dozens of likes in the weeks since, and was publicly announced. The mini has neither the announcement nor the adoption — in its first day it registered single-digit likes and no downloads at all.

The one piece of third-party attention the mini has drawn so far is an aggregator page that republished the model card within hours of the repo appearing; it is a mirror of the card, not an independent source, and it carries no information the repository itself does not. That is the entire public record as of September 6. The framing that matters for a reader deciding whether to pay attention: inclusionAI has now twice shipped diffusion weights quietly in the same week — this model on September 5, and the LLaDA-Image generation checkpoints the day before — so a quiet repo drop appears to be an established release pattern for the lab, not an accident. Nothing about that pattern tells us whether an announcement is coming.

What LLaDA2.2-mini actually is

The architecture is where the model is most interesting, and it is fully described on the card. LLaDA2.2-mini is a mixture-of-experts diffusion language model built on the LLaDA2.0-mini backbone. Diffusion language models invert the usual generation loop: instead of an autoregressive model predicting one next token at a time, a diffusion LLM starts from a block of masked or noisy tokens and refines the whole block in parallel, denoising toward a coherent sequence. The LLaDA2.2 generation adds what inclusionAI calls Levenshtein editing: two control tokens, DELETE and INSERT, that let the decoder change the length and structure of the sequence it is producing rather than only the contents — removing a redundant span it already wrote, or opening an insertion point where new context (say, a tool result) needs to go. That is the mechanism the family uses to make diffusion decoding work in multi-turn, tool-using loops, where an autoregressive model can simply wait for the next user turn but a block-diffusion model has to revise what it has already generated.

The relevant specifications, all straight from the card: 16 billion total parameters excluding embeddings, 1.4 billion active per token through a 256-expert MoE with 8 experts routed per token; 20 layers, 16 attention heads, 4 KV heads; a 157,184-token vocabulary; rotary position embeddings; and a 128K context window. A technique called Block Routing restricts which experts fire at the diffusion-block level, which is how the model keeps a 128K context tractable on a single consumer GPU. The card positions it for a 24GB-plus card and recommends SGLang as the serving backend for long-context agentic workloads.

Above is where the release sits in the family timeline — the lineage that makes "LLaDA2.2-mini" legible. LLaDA2.0 in November 2025 was the first diffusion language model scaled to 100 billion parameters; LLaDA2.1 in February 2026 added token editing for faster text diffusion; the LLaDA2.2 generation in July 2026, announced with LLaDA2.2-flash and its technical report, pointed the family at agents. The mini is the piece of that generation that stayed a promise until now: coverage of the July release already mentioned a lighter 16B variant of the flash for cheaper deployment, but the standalone weights only materialized on September 5.

The numbers on the card, labeled as what they are

The benchmark table on the model card is inclusionAI's own, printed the day the weights went up, and no independent lab has reproduced any of it — Artificial Analysis has no entry for LLaDA2.2-mini, and we can find no third-party run. Read the figures as the vendor's claims with a direction, not as measured facts. Within that frame, the story the card tells is consistent: LLaDA2.2-mini is an agentic and long-context specialist, and it trades some general-benchmark points to get there.

• Agentic average — 59.00, from τ²-Bench 57.50, Claw-Eval 57.16, and PinchBench 62.33 (vendor-reported).

• Function calling — 47.68 on BFCL v4, up from 25.05 and 28.44 for the LLaDA2.0-mini and LLaDA2.1-mini respectively; 69.02 on the older BFCL v3.

• Long context — 34.99 on LongBench v2, more than double the 15.51 and 12.13 the previous minis managed, which is the concrete payoff of the 128K window.

• General — a 46.47 general average, with AIME 2026 at 35.05, OlympiadBench 61.11, LiveCodeBench v6 28.14, GPQA-Diamond 44.41, and IFBench 24.93 — several of those slightly below the earlier minis, the visible cost of spending training budget on agentic behavior instead.

That last point is worth sitting with, because it is the honest reason a team would choose this model over a stronger-on-paper generalist. LLaDA2.2-mini is not claiming to be the best small model at math or instruction following; it is claiming to be good at the thing diffusion models were historically bad at — sustained, multi-turn, tool-using work — while keeping the active parameter count low enough to matter on one GPU. The BFCL v4 jump and the LongBench v2 jump are the numbers that would survive an independent run if the card is broadly right.

Running it, and the missing scaffolding

On paper the path to running LLaDA2.2-mini is straightforward, because the release is a Transformers-native one: the card shows loading it with AutoModelForCausalLM and trust_remote_code=True on transformers ≥ 5.2.0, then calling generate with diffusion-specific parameters — a block length of 32 and temperature 0.0 are the recommended defaults, and the card suggests a 32,768-token output length for most queries. For agentic long-context serving it points to SGLang, and mainland-China users get a ModelScope mirror. What does not exist yet is the surrounding ecosystem: no hosted API on any provider we can verify, no GGUF builds we can find, and framework support that is still settling — the community llama.cpp LLaDA2 architecture work is recent, so the quantization story is thin.

That combination — a genuinely new decoding paradigm, one day old, self-host-only — is exactly the situation where a routing layer earns its keep without pretending the new model is production-ready. The way to try LLaDA2.2-mini responsibly is to run it yourself on a test path while production stays on a mature model, and that is what OrcaRouter's setup is for: one API across 200-plus models at provider list price with 0% markup, automatic failover so the day-old checkpoint stalling does not take a workflow down, and the routing DSL to compose a self-hosted diffusion call with hosted autoregressive models behind a single key. When — if — a provider lists LLaDA2.2-mini, the same pass-through applies and the price you see is the provider's own. Until then the honest availability line is: download the Apache-2.0 weights from Hugging Face or ModelScope and run them yourself.

What to watch next

Three things would turn this what-we-know-so-far into a real story, and all three are absent today. First, an announcement: if the LLaDA2.2-flash pattern holds, a launch post and technical-report coverage could follow the quiet repo drop, and it would likely add training details the card omits. Second, an independent run: the agentic average of 59.00 and the BFCL v4 score of 47.68 are the claims most worth reproducing, because agentic benchmarks are the ones where harness choice moves scores the most. Third, serving maturity: SGLang serving guides, a vLLM path, and community quantizations would tell you whether the 1.4B-active footprint is as cheap to operate in practice as the spec sheet suggests. None of those exist on September 6. The weights are real, the license is permissive, and the architecture genuinely is a different way of running an agent — but the evidence that it is a good agent is, for now, one vendor's card.