Verdict: Ling 3.0 Flash is Ant Group's open-weight AI model that packs 124 billion total parameters into a Mixture-of-Experts architecture activating only 5.1 billion per token — roughly one-twelfth the active compute of a typical frontier model — while claiming to match models two to three times its size on agent benchmarks. Released July 23, 2026 by InclusionAI (Ant Group's AI lab), it is now live on Hugging Face under the MIT license with both BF16 and FP8 checkpoints, a 262,144-token context window, and native hybrid reasoning. For teams building production AI agent workflows that need long context, tool calling, and fast inference without paying per-token API tax, it is one of the most efficient open-weight options available in August 2026 — but independent benchmarks show it is mid-pack on raw intelligence, so it is a deployment play, not a frontier-replacement.
Last verified: 2026-08-08
- Ling 3.0 Flash: 124B total, 5.1B active, hybrid-linear MoE, MIT license (Hugging Face model card)
- Context: 262,144 tokens native, scalable to 1M (Hugging Face model card)
- Free API: OpenRouter
inclusionai/ling-3.0-flash:free, 200 requests/day (OpenRouter)- Hardware: 4× 141GB GPUs for BF16, 2× for FP8 (Hugging Face model card)
- Pricing/limits and hardware costs change often — re-check before production deployment.
What Is Ling 3.0 Flash and Why Does It Matter for AI Agents?
Ling 3.0 Flash is a Mixture-of-Experts (MoE) large language model built by InclusionAI — the open-source AI research lab inside Ant Group, the company behind Alipay — and released on July 23, 2026. It is designed specifically for production AI agent workflows: multi-step, tool-calling, autonomous loops where a model plans, executes, reads results, and iterates — not single-shot chat (Business Wire via Morningstar).
The headline is the efficiency ratio. The model carries 124 billion total parameters but only activates about 5.1 billion per token during inference. That is roughly one-twelfth the active compute of a model like DeepSeek V4 Pro (49B active) and one-eighth the total parameter count of Ant Group's own previous 1T-class flagship. Despite that, InclusionAI claims it "matches or surpasses" models with two to three times its parameter scale across core benchmarks including foundational reasoning, instruction following, and long-context processing (Business Wire).
Why this matters for agents: AI agent loops run hundreds or thousands of inference calls over hours of unattended work. A model that activates 5.1B parameters instead of 49B per token creates an order-of-magnitude cost difference — the gap between a $5/day infrastructure bill and a $50/day one. For a deeper look at why this cost ratio is the decision that makes or breaks agent deployments, see our guide on LLM model routing in 2026.
How Does Ling 3.0 Flash's MoE Architecture Work?
Ling 3.0 Flash uses a hybrid-linear Mixture-of-Experts architecture that combines two innovations: sparse expert routing and a hybrid attention mechanism. Here is what each does in plain terms.
Sparse Mixture-of-Experts: 512 experts, 8 active
A Mixture-of-Experts model is like having a room of 512 specialists. Every time the model processes a token, a router network picks the 8 most relevant experts for that specific token and only runs those. The other 504 experts sit idle. This is how Ling 3.0 Flash activates only 5.1B of its 124B total parameters per token.
The official model card confirms the architecture (Hugging Face):
| Spec | Value |
|---|---|
| Architecture | Hybrid-linear MoE |
| Total parameters | 124B |
| Active parameters per token | 5.1B |
| Routed experts | 512 |
| Shared experts | 1 |
| Activated experts per token | 8 |
| Expert activation ratio | 1/64 (down from 1/32 in previous generation) |
| Attention heads | 32 |
| Hidden size | 2,560 |
| Vocabulary size | 157,184 |
| Context training schedule | 8K → 32K → 256K |
The 1/64 activation ratio is aggressive. InclusionAI's own earlier research recommended 1/32 as the efficiency sweet spot up to 1T parameters, so pushing to 1/64 at the 124B class is a bet that the extra sparsity pays off in inference cost without degrading quality. Early independent measurements suggest the quality trade-off is real but modest — BenchLM scores Ling 3.0 Flash at 49.9 out of 100, ranking #122 of 216 tracked models (BenchLM).
Hybrid-linear attention: KDA + MLA at 5:1
The other half of the architecture is the attention mechanism. Ling 3.0 Flash alternates two types of attention layers in a 5:1 ratio:
- Kimi Delta Attention (KDA) — 35 layers. A linear attention variant that enables efficient long-context processing. It uses fine-grained diagonal gating in Delta Rule state updates, which lets the model retain critical information across lengthy documents and codebases without the quadratic memory cost of standard attention.
- Gated Multi-Head Latent Attention (MLA) — 7 layers. A more traditional attention mechanism that provides robust state memory for complex reasoning.
This hybrid approach is the key to the model's 262K-token context window (extendable to 1M). Linear attention handles the long-context throughput cheaply; MLA layers provide the reasoning depth at critical points. For agent workflows that need to ingest entire codebases or long conversation histories, this matters more than raw benchmark scores.
For more on why MoE architecture is now the dominant paradigm for open-weight models — and what it means for your inference bill — see our analysis of how MoE and sparse attention reshape LLM infrastructure in 2026.
What Are Ling 3.0 Flash's Benchmark Scores?
The benchmark picture is mixed and worth reading carefully. InclusionAI published scores on several agent-focused benchmarks, but independent testing paints a more measured picture than the vendor's headline claims.
Vendor-reported scores (from the official model card)
| Benchmark | Score | Source |
|---|---|---|
| SWE-Bench Pro | 56.6 | Hugging Face model card |
| SWE-Bench Multilingual Resolved | 72.4 | Hugging Face model card |
| MathArena AIME 2026 | 93.2 | Hugging Face model card |
| HMMT Feb 2026 | 87.0 | Hugging Face model card |
| HLE (Humanity's Last Exam) | 22.7 | Hugging Face model card |
These are strong scores for a 5.1B-active model. SWE-Bench Pro at 56.6 means it can resolve over half of professional software engineering tasks in the OpenHands evaluation harness. AIME 2026 at 93.2 is exceptional for math competition problems.
Independent scores (third-party evaluation)
BenchLM, an independent benchmark aggregator, provides a more grounded view (BenchLM):
| Category | Rank | Score | Percentile |
|---|---|---|---|
| Overall | #122 of 216 | 49.9 | 56th |
| Instruction Following | #20 of 36 | 78.8 | 46th |
| Coding | #62 of 132 | 50.2 | 53rd |
| SciCode | — | 41.2% | — |
| Knowledge (GPQA) | Not ranked | 34.4 | — |
| Math | Not ranked | 74.1 | — |
The independent picture: Ling 3.0 Flash is solidly mid-pack. Its strongest category is instruction following (#20 of 36), which is exactly what agent workflows need — agents that follow instructions reliably can execute multi-step plans without drifting. But coding at the 53rd percentile and overall at the 56th percentile mean it is not replacing Claude Sonnet 4.6 or GPT-5.4 for complex reasoning tasks.
The honest read: Ling 3.0 Flash is not a frontier model. It is an efficiency model. The value proposition is "good enough intelligence at one-twelfth the compute" — and for many agent workflows (content drafting, lead qualification, data extraction, customer onboarding), "good enough" is exactly what the job requires. For guidance on when to use a budget model versus a frontier one, see our budget AI model decision guide comparing DeepSeek V4 Flash vs GPT-5.6 Luna.
How Much Does Ling 3.0 Flash Cost to Run?
The cost story has two layers: the API (if you use a hosted provider) and self-hosting (if you run it yourself).
API access (free during launch, then metered)
At launch, Ling 3.0 Flash was available free through August 3, 2026 across four inference providers. Post-promotional pricing has not been officially published, but the predecessor Ling 2.6 Flash settled at approximately $0.01 per million input tokens and $0.03 per million output tokens on OpenRouter after its own free window closed (Awesome Agents).
As of August 2026, the model is still listed on OpenRouter as inclusionai/ling-3.0-flash:free with a 200-request-per-day rate limit on the free tier (OpenRouter, FreeLLM).
| Provider | Model ID | Access | Context | Limit |
|---|---|---|---|---|
| OpenRouter | inclusionai/ling-3.0-flash:free |
Free tier | 262K | 200 req/day |
| Novita | inclusionai/ling-3.0-flash-20260723 |
Free endpoint | 262K | Not published |
| Vercel AI Gateway | inclusionai/ling-3.0-flash-free |
Free (through Aug 3) | 262K | Provider pricing after |
Self-hosting (open weights, MIT license)
The weights are now publicly available on Hugging Face under the MIT license, which means you can download them, run them on your own hardware, fine-tune them, and build commercial products — no per-token cost, no vendor lock-in.
Two checkpoints are available (Hugging Face BF16, Hugging Face FP8):
| Checkpoint | Size | Hardware needed | Best for |
|---|---|---|---|
| BF16 (full precision) | ~255 GB | 4× 141GB GPUs (or 8× 80GB H100/H800) | Research, fine-tuning, maximum accuracy |
| FP8 (quantized) | ~128 GB | 2× 141GB GPUs | Production serving, lower memory, faster inference |
The FP8 checkpoint is the practical choice for most business applications. According to InclusionAI's own evaluation, the quality drop from BF16 to FP8 is minimal — the FP8 variant scores similarly on GPQA (84% vs comparable BF16 results) and instruction following (BenchLM FP8 profile).
Both checkpoints are served via SGLang or vLLM. The model card includes Docker commands for one-command deployment (Hugging Face).
How to Self-Host Ling 3.0 Flash (Step-by-Step)
The model card documents two deployment paths: SGLang and vLLM. Here is the SGLang path using the official Docker image.
Step 1: Pull the SGLang Docker image
docker pull lmsysorg/sglang:dev-Ling-3.0-flash
Step 2: Launch the inference server (4× 141GB GPUs)
docker run --rm --gpus all --ipc=host --shm-size 32g \
-p 30000:30000 \
-e HF_TOKEN=<your-hf-token> \
lmsysorg/sglang:dev-Ling-3.0-flash \
env SGLANG_ALLOW_OVERWRITE_LONGER_CONTEXT_LEN=1 \
python3 -m sglang.launch_server \
--model-path inclusionAI/Ling-3.0-flash \
--tp 4 \
--context-length 262144 \
--speculative-algorithm NEXTN \
--mem-fraction-static 0.8 \
--host 0.0.0.0 \
--port 30000
On 80GB cards like H100 or H800, use --tp 8 (tensor parallelism across 8 GPUs) instead of 4.
Step 3: Send a test request
curl -s http://localhost:30000/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "inclusionAI/Ling-3.0-flash",
"messages": [{"role": "user", "content": "Write a Python function to parse a CSV file."}]
}'
The server exposes an OpenAI-compatible API, so any client that already talks to chat/completions works after swapping the base URL.
Step 4: For FP8 (lower hardware requirement)
Use the FP8 checkpoint on 2 GPUs instead of 4:
docker run --rm --gpus all --ipc=host --shm-size 32g \
-p 30000:30000 \
-e HF_TOKEN=<your-hf-token> \
lmsysorg/sglang:dev-Ling-3.0-flash \
python3 -m sglang.launch_server \
--model-path inclusionAI/Ling-3.0-flash-fp8 \
--tp 2 \
--context-length 262144 \
--host 0.0.0.0 \
--port 30000
Key parameters (from the model card):
- Thinking mode is enabled by default:
temperature=0.6, top_p=0.95, top_k=20 - For SWE-Bench evaluations:
temperature=0.6, top_p=0.95, max_new_tokens=32K, 256K context - For MiniAppBench (interactive HTML apps):
temperature=1.0, top_p=1.0, max_tokens=128K
If you are new to self-hosting open-weight models and need a broader primer on VRAM math, quantization, and runtime choice, our guide to running a 26B AI model on a Mac with MoE SSD streaming covers the fundamentals.
What Are the Best AI Agent Workflows for Ling 3.0 Flash?
Ling 3.0 Flash was trained across over 10,000 interactive environments for end-to-end closed-loop execution across coding, general tasks, and deep research agent tasks (Business Wire). It also natively integrates SGLang HiCache and Mooncake hierarchical caching, which reduces Time-to-First-Token by 60% to over 80% in long-input scenarios — a critical metric for agent loops that build up large context windows over time.
Here are three production workflows where the model's profile (long context, fast first token, instruction-following, low cost) maps to real business needs.
1. Automated content planning from community data
The workflow: Feed a week of community posts, customer questions, and support tickets into the model. Ask it to identify the top three pain points and generate content ideas addressing each one.
Why Ling 3.0 Flash fits: The 262K context window can ingest thousands of posts in a single pass. The instruction-following strength (#20 of 36 on BenchLM) means it produces structured, actionable output. The low active-parameter count means you can run this daily without a significant compute bill.
2. Personalized onboarding sequences
The workflow: When a new customer or member joins, pass their intake form (business type, biggest challenge, goals) to the model. Generate a personalized welcome message pointing them to the most relevant resources, the right session to attend, and connections to make.
Why Ling 3.0 Flash fits: This is a template-generation task, not a frontier-reasoning task. The model's instruction-following and long-context capabilities are sufficient, and running it on your own hardware means customer data never leaves your network — a compliance advantage for regulated industries.
3. Lead qualification and follow-up email sequences
The workflow: When a prospect visits a sales page but does not convert, pass their browsing data and any form responses to the model. Generate a three-part email sequence addressing common objections (time, relevance, confidence) with real examples.
Why Ling 3.0 Flash fits: Email copy is a writing task where "good enough" intelligence at low cost beats "best possible" intelligence at high cost. The model's 262K context can hold your entire sales page, competitor pages, and objection-handling playbook for the model to draw from.
For a deeper dive into building these kinds of automated pipelines, see our guide on how to build an AI agent operating system in 2026.
How Does Ling 3.0 Flash Compare to Other Open-Weight Agent Models?
Ling 3.0 Flash enters a crowded field. Here is how it stacks against the other major open-weight models used for AI agent workflows in August 2026.
| Model | Maker | Total params | Active params | Context | License | Best for |
|---|---|---|---|---|---|---|
| Ling 3.0 Flash | Ant Group | 124B | 5.1B | 262K | MIT | Cost-efficient agent execution |
| DeepSeek V4 Pro | DeepSeek | 1.6T | 49B | 1M | MIT | Frontier-level coding and reasoning |
| Kimi K2.6 | Moonshot AI | 1T | 32B | 256K | Modified MIT | Agentic coding at scale |
| GLM-5.2 | Zhipu AI | 753B | ~40B | 1M | MIT | Coding and reasoning at lower serving cost |
| Qwen 3.6 35B-A3B | Alibaba | 35B | 3B | 256K | Apache 2.0 | Edge and single-GPU deployment |
| gpt-oss-120b | OpenAI | 117B | 5.1B | 128K | Apache 2.0 | Reasoning near o4-mini on one GPU |
The pattern: Ling 3.0 Flash and gpt-oss-120b share nearly identical efficiency profiles (both activate ~5.1B parameters). The difference is context (262K vs 128K) and focus (agents vs reasoning). DeepSeek V4 Pro and Kimi K2.6 are in a different weight class — they activate 10-25x more parameters per token, which means higher intelligence but also higher serving cost.
For teams that already have infrastructure for an open-weight model, Ling 3.0 Flash slots in as a "fast execution node" — the model that handles the routine steps in an agent loop (data extraction, drafting, simple tool calls) while a larger model handles the hard reasoning. This is the "planning-execution separation" paradigm InclusionAI explicitly designed the model for.
For more on this model-tiering strategy, see our guide on how to plug a new LLM into an existing agent framework and the broader open-source AI model landscape in 2026.
What This Means for You
If you are a small business or solo builder: Ling 3.0 Flash's free tier on OpenRouter (200 requests/day) is enough to prototype agent workflows without any spend. Start there. If the workflow works, the question becomes whether to scale on the API or self-host. Self-hosting requires 2-4 high-end GPUs (FP8 needs 2× 141GB; BF16 needs 4× 141GB), so it only makes sense above roughly 10 million tokens per month — below that, the managed API is cheaper.
If you are an engineering team: The MIT license is the cleanest part of the story. You can fine-tune the model on your domain data, deploy it on your own infrastructure, and build commercial products with no per-token cost and no vendor dependency. The hybrid-linear attention architecture makes it particularly good at long-context tasks (codebase ingestion, document analysis) where standard attention would be prohibitively expensive.
If you are evaluating Chinese AI models: Ling 3.0 Flash is part of a broader wave of open-weight models from Chinese labs — DeepSeek, Qwen, GLM, Kimi, and now Ant Group — that are reshaping the price-performance frontier. For context on what this means for pricing competition and vendor risk, see our analysis of how China's open-weight models are forcing Anthropic and OpenAI to compete on price and the investment-risk perspective on Moonshot AI's $35B valuation and Chinese AI models.
FAQ
Q: Is Ling 3.0 Flash open source?
A: Ling 3.0 Flash is open-weight under the MIT license, meaning you can download the model weights from Hugging Face, self-host them, fine-tune them, and use them commercially. The training data and full training pipeline are not public, so it is technically "open weight" rather than fully "open source" under the OSI definition — but the MIT license gives you broad commercial freedom (Hugging Face model card).
Q: How much VRAM do I need to run Ling 3.0 Flash?
A: The BF16 checkpoint requires approximately 255 GB of VRAM, which means 4× 141GB GPUs or 8× 80GB H100/H800 cards. The FP8 checkpoint requires approximately 128 GB, which fits on 2× 141GB GPUs. The model card documents both SGLang and vLLM deployment paths (Hugging Face).
Q: How fast is Ling 3.0 Flash?
A: InclusionAI claims the model, paired with their hierarchical caching architecture (SGLang HiCache + Mooncake), reduces Time-to-First-Token by 60% to over 80% in long-input scenarios compared to their previous generation. Specific tokens-per-second figures depend on your hardware and serving framework. The architecture is designed for low-latency agent execution, not single-shot reasoning (Business Wire).
Q: Can I use Ling 3.0 Flash for free?
A: Yes. It is available free on OpenRouter as inclusionai/ling-3.0-flash:free with a 200-requests-per-day rate limit and a 262K context window. It is also free on Novita and was free on Vercel AI Gateway through August 3, 2026. The predecessor Ling 2.6 Flash settled at approximately $0.01/M input and $0.03/M output after its promotional period (OpenRouter, Awesome Agents).
Q: Is Ling 3.0 Flash better than DeepSeek V4?
A: No, not on raw intelligence. DeepSeek V4 Pro activates 49B parameters per token (nearly 10x more than Ling 3.0 Flash's 5.1B) and scores significantly higher on coding and reasoning benchmarks. Ling 3.0 Flash is designed as a cost-efficient execution node for agent workflows, not a frontier model. BenchLM ranks Ling 3.0 Flash at #122 of 216 models with a 49.9/100 score, while DeepSeek V4 Pro is in the top tier (BenchLM).
Q: What is the difference between Ling 3.0 Flash and Ling 2.6 Flash?
A: Ling 3.0 Flash (July 2026) has 124B total / 5.1B active parameters, a hybrid-linear MoE architecture with KDA+MLA attention, and 262K context. Ling 2.6 Flash (April 2026) had 104B total / 7.4B active parameters and a more conventional MoE architecture. The 3.0 generation pushes the activation ratio from 1/32 to 1/64 (more sparsity), adds hybrid reasoning (dual thinking/non-thinking modes), and introduces the hybrid-linear attention mechanism for better long-context efficiency (Hugging Face, Awesome Agents).
Every claim here is traced to a primary source, dated, and listed under Sources. Research and drafting are AI-assisted; editing, verification and publication are human decisions, and a person is accountable for what appears on this page. How we work →
Discussion
0 comments