Efficient reasoning is becoming the battleground for open model releases, and Ant Group’s Ling-3.0-tiny is the latest entry: a hybrid reasoning MoE with 7.9B total parameters and only 1.3B activated per token, in BF16, FP8, and INT4 variants, built for strong agentic and reasoning performance at low inference cost.
What Was Released
On August 11, the Ant Ling team announced Ling-3.0-tiny, the lightweight addition to the Ling-3.0 series. The model ships under an MIT license on Hugging Face and ModelScope, with an OpenRouter endpoint already live. The design target is stated plainly in the model card: deliver strong reasoning and agentic capabilities at low inference cost, making advanced capabilities accessible for local and resource-constrained deployment.
The architecture is where the model gets interesting. Ling-3.0-tiny integrates a 3:1 alternating stack of KDA and MLA attention layers, three Kimi Delta Attention layers followed by one Multi-Head Latent Attention layer per four-layer block, with a sparse MoE FFN comprising 128 routed experts. Each token activates only 8 routed experts plus 1 shared expert. That adds up to 7.9B total parameters but just 1.3B activated per token, which is the number that determines inference cost and latency.
The model also supports native hybrid reasoning. It can produce fast responses for routine tasks or engage in multi-step reasoning for complex ones, with thinking mode configurable per request through an `enable_thinking` flag. That per-request control is a practical detail: you do not pay reasoning tokens for a simple lookup, and you can turn them on when the task actually needs deliberation.
The Numbers That Matter
The efficiency numbers are the substance of the release. On NVIDIA DGX Spark with FP8, Ling-3.0-tiny reaches roughly 100 to 105 tokens per second, and about 86 to 90 tokens per second on an M4 Pro MacBook, with approximately 8.34 GiB peak memory usage at an 8K context length. Those are the kind of numbers that make a reasoning-capable model feel native on hardware a developer already owns, rather than something that requires datacenter-class GPUs.
The model card also cites Artificial Analysis testing: a score of 25 on the Artificial Analysis Intelligence Index v4.1.1 and 16 on the Artificial Analysis Agentic Index, with output speed above 160 tokens per second and roughly 18 seconds of end-to-end latency for a 500-token response including reasoning time. The 1.3B activated footprint is the context for those numbers, which is what makes them notable rather than just good.
Terminal-Bench 2.1 evaluation is reported under the Artificial Analysis protocol using the Terminus 2 harness, with a 256K context window and up to 32K new tokens. The recommended sampling parameters are temperature 1.0, top_p 0.95, and top_k 20, with thinking mode enabled by default.
Why This Matters
Ling-3.0-tiny sits inside a clear 2026 trend: small activated-parameter models that punch above their weight on agentic tasks. The reasoning market has bifurcated into frontier models with enormous compute footprints and efficient models designed to run where the work actually happens. This release is squarely in the second camp, and the 1.3B active count is aggressive even for that category.
The agent angle matters more than the raw benchmarks. A model that runs at 100 tokens per second on a DGX Spark or an M4 Pro, with native tool-calling support in the chat template and a 256K context, is a credible backbone for local agents. That is the use case the model card emphasizes, validated deployment on DGX Spark, Apple Silicon MacBook, and Mac mini, enabling “capable reasoning and agentic workloads without datacenter-class GPUs.”
The MIT license is worth noting separately. Most open-weight releases use permissive licenses now, but MIT is at the permissive end, and it removes questions about commercial use, redistribution, and fine-tuned derivatives. For a company shipping a product on top of a model, that is a meaningful difference from licenses with attribution or share-alike terms.
For developers thinking about small-model deployment patterns, our piece on fine-tuning an 8B model on 4GB of GPU memory covers the memory-side of running compact models, which pairs well with understanding what a 1.3B-activated model can actually sustain in production.
The Honest Caveats
A 1.3B-activated model is not a frontier model, and the benchmark numbers should be read with that in mind. A score of 25 on the Artificial Analysis Intelligence Index places it well below the top reasoning models, which is expected for the size class. The value proposition is efficiency and accessibility, not topping leaderboards, and anyone choosing it for a task that needs frontier reasoning will be disappointed.
The KDA-MLA hybrid architecture is Ant’s own design, which means the ecosystem around it is younger than for established architectures. Inference support is good, with SGLang cookbooks and prebuilt Docker images, but community experience with fine-tuning and quantization is thinner than it would be for a model built on a more standard stack.
The deployment validation is also specific. The headline throughput numbers are on DGX Spark and M4 Pro, both capable hardware. On older consumer machines the experience will be slower, and the 8.34 GiB peak memory figure is at 8K context, which grows with longer contexts even with the efficient attention design.
Who Should Use It
Developers building local or edge agents with modest hardware budgets are the primary audience. The combination of 1.3B activated parameters, 256K context, native tool calling, and per-request thinking control makes it a serious candidate for agent backbones on Apple Silicon or DGX-class machines.
Teams that want an MIT-licensed base for fine-tuning into specialized workflows, researchers working with constrained compute, and anyone who wants a reasoning-capable model running entirely offline should evaluate it. The FP8 and INT4 variants lower the hardware bar further, and the OpenRouter endpoint means you can test the model without deploying anything.
The Bottom Line
Ling-3.0-tiny is a well-executed entry in the compact reasoning MoE category: 1.3B activated parameters, hybrid attention, native hybrid reasoning with per-request control, MIT license, and credible agentic benchmarks. The real test is how it holds up in production agent workflows, where the combination of throughput and tool-calling reliability matters more than any single benchmark. If you are building agents for local or resource-constrained deployment, it is worth downloading this week and measuring against your own workloads.