Ling 3.0 Tiny is a Mixture-of-Experts reasoning model from InclusionAI (Ant Group's AI lab) that activates only 1.3 billion of its 7.9 billion total parameters per token — yet scores 25 on the Artificial Analysis Intelligence Index, three times the median of 8 for reasoning models in its price tier. Released August 6, 2026, it is free to use through OpenRouter and Vercel AI Gateway, offers a 262K-token context window with native function calling and prompt caching, and is designed for agent workflows on edge devices. The open weights are promised but not yet available, so you cannot self-host today — but you can start building agent workflows against the hosted API immediately.
Last verified: August 9, 2026 · Free until August 14, 2026 (8am PT) on Vercel AI Gateway; indefinitely free tier on OpenRouter · Specs may change after promo period
TL;DR:
- 7.9B total parameters, 1.3B active per token (~16% activation ratio) — knowledge of a big model at near-small-model compute cost
- Artificial Analysis Intelligence Index: 25 (rank #6 of 56 in its class, class median 8)
- 262K context window, 32K max output, 184 tokens/second output speed
- Free via OpenRouter (
inclusionai/ling-3.0-tiny:free) and Vercel AI Gateway - Switchable Thinking and Instant modes — deep reasoning or fast responses on demand
- Open weights announced but not yet downloadable; cannot self-host today
What Is Ling 3.0 Tiny?
Ling 3.0 Tiny is the smallest model in the Ling 3.0 series from InclusionAI, Ant Group's open AI lab. It is a hybrid reasoning model built on the Mixture-of-Experts (MoE) architecture, with 7.9 billion total parameters but only 1.3 billion activated per token — roughly 16% of the model's full capacity fires on any given input. The model supports on-device deployment and local offline execution, with balanced performance across scientific reasoning, code, real-world tasks, and long context. InclusionAI describes it as built for responsive agents, instruction following, and multi-turn conversations. (InclusionAI developer docs)
The "Tiny" label positions it as the edge-deployable sibling in a three-model family:
| Model | Total Params | Active Params | Context | Positioning |
|---|---|---|---|---|
| Ling 3.0 Tiny | 7.9B | 1.3B | 262K | Edge deployment, on-device, local offline |
| Ling 3.0 Flash | 124B | 5.1B | 256K (extendable to 1M) | Cost-efficient production, high throughput |
| Ling 2.6-1T | ~1T | 63B | 1M | Flagship, ultra-long reasoning chains |
(InclusionAI developer docs) — For a deeper look at the mid-tier sibling, see our guide to the Ling 3.0 Flash 124B MoE model.
Why Does Only 1.3B of 7.9B Parameters Activate Per Token?
Because Ling 3.0 Tiny uses a Mixture-of-Experts architecture, which splits the model's feed-forward layers into many specialized sub-networks (experts), plus a small router that picks which experts handle each token. Instead of waking up the entire 7.9 billion parameters for every request, a router selects only the most relevant experts — roughly those encoding the knowledge needed for this particular token — and the rest stay idle. The result is that inference cost tracks active parameters (~1.3 billion) while answer quality benefits from the full knowledge stored across all 7.9 billion parameters. (Hugging Face Mixture of Explained)
This is the same architectural pattern behind most 2026 frontier models — from DeepSeek to Qwen to Kimi — and it is the reason models can keep getting larger without getting proportionally more expensive to run. Inference cost roughly equals active parameters; answer quality roughly tracks total parameters. Ling 3.0 Tiny's 16% activation ratio means you get the knowledge of a 7.9B model at close to the compute cost of a 1.3B dense model. For a broader primer on how this works and the trade-offs involved, see our LLM quantization and edge inference guide.
How Much Does Ling 3.0 Tiny Cost?
As of August 9, 2026, Ling 3.0 Tiny is free to use through two API providers. On OpenRouter, the model is listed as inclusionai/ling-3.0-tiny:free with $0.00 per million input tokens and $0.00 per million output tokens. On Vercel AI Gateway, it is available as inclusionai/ling-3.0-tiny-free, free until August 14, 2026 at 8:00am Pacific Time, after which it moves to standard pricing under the model name inclusionai/ling-3.0-tiny. (OpenRouter, Vercel changelog)
Post-promo pricing has not yet been published. The OpenRouter free tier has a rate limit of roughly 200 requests per day (provider policy, subject to change). Confirm current rates on the provider's dashboard before committing to production traffic.
How Fast Is Ling 3.0 Tiny?
Ling 3.0 Tiny generates output at 184.1 tokens per second with a time-to-first-token of 1.86 seconds, based on InclusionAI's first-party API as measured by Artificial Analysis. The speed ranks #10 of 56 models in its class (class median: 145.5 tokens/second), placing it above average for reasoning models at a similar price point. The 1.86-second TTFT is somewhat higher than the class median of 0.97 seconds, meaning there is a brief delay before the first token appears — typical for reasoning models that may do internal "thinking" before responding. (Artificial Analysis)
| Metric | Ling 3.0 Tiny | Class median (56 models) |
|---|---|---|
| Intelligence Index | 25 | 8 |
| Output speed | 184.1 tok/s | 145.5 tok/s |
| Time to first token | 1.86s | 0.97s |
| Input price | $0.00/M | $0.03/M |
| Output price | $0.00/M | $0.11/M |
Data from Artificial Analysis, accessed August 9, 2026.
How Do You Use Ling 3.0 Tiny?
You can call Ling 3.0 Tiny through any OpenAI-compatible API client by pointing it at OpenRouter or Vercel AI Gateway and setting the model ID. Below is a minimal TypeScript example using the Vercel AI SDK:
import { streamText } from 'ai';
const result = streamText({
model: 'inclusionai/ling-3.0-tiny-free',
prompt: 'Summarize this thread and draft a reply.',
});
For Python users, any OpenAI-compatible SDK works — just swap the base URL and model name:
from openai import OpenAI
client = OpenAI(
base_url="https://openrouter.ai/api/v1",
api_key="your-openrouter-key"
)
response = client.chat.completions.create(
model="inclusionai/ling-3.0-tiny:free",
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Draft a re-engagement email for inactive community members."}
]
)
Step 1: Get an API key
Create a free account on OpenRouter or use Vercel AI Gateway. Both platforms expose the model with an OpenAI-compatible endpoint.
Step 2: Choose your mode — Thinking or Instant
Ling 3.0 Tiny has two switchable modes: Instant mode for fast, simple tasks and Thinking mode for harder, multi-step reasoning. Use Instant for quick replies, summaries, and answers that do not require deep chain-of-thought. Use Thinking for planning, analysis, code reasoning, and any task where the model needs to work through intermediate steps before answering. (Vercel AI Gateway model page)
Step 3: Wire up function calling for agent workflows
Ling 3.0 Tiny has native function calling built in, meaning the model can trigger external actions — search the web, pull from a database, send data to a tool — rather than just generating text. This is what makes it suitable for agent loops rather than one-shot chat. A simple agent workflow looks like:
- Define your tool schema (function name, arguments, return format)
- Send the user query + tool definitions to the model
- The model decides which tool to call and returns arguments
- Your code executes the tool and feeds the result back
- The model uses the result to continue or finish
Step 4: Use prompt caching for repeated context
If your agent runs on a schedule and reuses large blocks of context — system instructions, tool definitions, repository documentation — prompt caching stores that repeated chunk so the model does not reprocess it from scratch on every call. This reduces latency and compute cost for daily workflows. (Vercel changelog) — For more on managing token costs in production agent systems, see our guide on AI token cost optimization for enterprises.
What Are the Best Use Cases for Ling 3.0 Tiny?
The model is designed for scenarios where low active compute, long context, and tool use all matter together. Based on InclusionAI's own positioning and confirmed capabilities, the strongest fit is in agent workflows that run frequently, handle large context windows, and rely on function calling. (InclusionAI developer docs)
| Use case | Why Ling 3.0 Tiny fits |
|---|---|
| Community/customer re-engagement agents | 262K context holds a month of conversation history; function calling can query a CRM and draft personalized messages |
| Daily insight agents | Prompt caching reduces cost for repeated daily runs; long context ingests 24 hours of activity in one pass |
| Content planning | Thinking mode reasons over multiple inputs (member questions, topic gaps, tool inventory) to produce structured plans |
| Lightweight code assistance | 7.9B total architecture with low active cost makes it practical for repeated code help in real time |
| Edge / on-device agents (future) | Designed for local offline execution and privacy-sensitive deployments — once weights are released |
| Multi-document reasoning | 262K context window = roughly 393 A4 pages of text, far beyond the 8K–32K typical of small models |
For teams evaluating this model against alternatives, the test that matters is not a generic benchmark but your own agent loop: can the model plan, call tools, revise after feedback, and keep the task on track? Run the same workflow against Ling 3.0 Tiny and a model you already trust (say, Claude or a local Gemma build), with identical tool contracts and acceptance criteria, and compare.
If you are looking at building on-device agents more broadly — not just Ling 3.0 Tiny — our free local AI agent setup guide for 2026 walks through the full open-source self-hosted path.
How Does Ling 3.0 Tiny Compare to Other Small Models?
Most models in the sub-8B parameter range top out at 8,000 to 32,000 tokens of context and lack native function calling, forcing you to bolt on tool-use frameworks externally. Ling 3.0 Tiny's 262K context window is roughly 8–32× larger than typical peers in its size class, and its built-in function calling and prompt caching remove the need for external orchestration layers for simple agent loops. The trade-off is that Ling 3.0 Tiny is proprietary — the weights are not yet downloadable — so you are locked to the hosted API. By contrast, open-weight models like Gemma 4 or Qwen Community can run locally on your own hardware, which matters for privacy-sensitive or offline deployments. (OpenRouter, ModelCompare)
| Feature | Ling 3.0 Tiny | Typical sub-8B dense model |
|---|---|---|
| Architecture | MoE (7.9B total / 1.3B active) | Dense (all params active) |
| Context window | 262K tokens | 8K–32K tokens |
| Function calling | Native | Usually not built in |
| Prompt caching | Yes | Rarely |
| Reasoning modes | Switchable (Thinking / Instant) | Usually single mode |
| Selfhost today | No (weights pending) | Often yes (if open-weight) |
| Price (Aug 2026) | Free (promo) | Varies |
For more on open-weight alternatives and the broader trend of Chinese labs releasing capable open models, see our article on how open-source AI models are rewriting the rules in 2026.
Can You Run Ling 3.0 Tiny Locally?
Not yet. InclusionAI has announced that the open weights are coming soon, but as of August 9, 2026, no model card or weights have been posted to the InclusionAI Hugging Face organization. The model is proprietary and only available through hosted APIs (OpenRouter and Vercel AI Gateway, both routing to Novita as the underlying inference provider). The developer docs state it "will be open-sourced in the near future" and is designed for on-device deployment and local offline execution — but that capability is not available today. (InclusionAI developer docs, Artificial Analysis)
If local, offline, privacy-first agents are your priority right now, consider open-weight models that are downloadable today. Our guide to running a local agentic OS without cloud or Wi-Fi covers how to combine a small open-weight model with an agent framework for fully private operation.
What Are the Limitations You Should Know?
Weights are not available. The single biggest caveat: you cannot self-host Ling 3.0 Tiny today. If your workflow requires complete data sovereignty (no third-party API calls), offline operation, or custom fine-tuning, you need to wait for the weights or choose an open alternative.
Very verbose. Artificial Analysis reports Ling 3.0 Tiny generated 210 million output tokens during its Intelligence Index evaluation, versus a class median of 63 million — meaning the model is roughly 3.3× more verbose than peers. For cost-sensitive or latency-sensitive use cases (especially after the free period ends), factor in the higher token output. (Artificial Analysis)
Text only. The model accepts only text input and produces only text output. No image, audio, or video processing. If you need multimodal, look elsewhere.
No structured output support. As of the OpenRouter listing, Ling 3.0 Tiny does not support JSON-schema-constrained decoding. You can use function calling, but if your workflow requires guaranteed JSON format adherence, you should test whether the model reliably produces valid JSON from prompt instructions alone. (ModelCompare)
Promotional pricing ends. The free window on Vercel closes August 14, 2026 at 8am PT. OpenRouter's free tier carries a ~200 requests/day rate limit. Production usage after the promo will require a published per-token price that is not yet available.
What This Means for You
If you are building AI agent workflows — automated community management, daily insight agents, customer support loops, or content planning pipelines — Ling 3.0 Tiny is worth testing right now while it is free. The combination of a 262K context window, native function calling, and a 1.3B active-parameter footprint means you can feed it an entire month of conversation history or a full document archive in a single call, have it trigger real tools, and do so at a compute cost closer to a small model than a frontier model.
The practical next step: pick one workflow you already run manually, define the tool contract (what the model should search, query, or look up), and run it through Ling 3.0 Tiny via OpenRouter. Compare the output quality, speed, and tool-handling discipline against whatever you use today. If the model handles the loop cleanly — especially the second-turn correction when your tool returns unexpected results — then it qualifies for that workflow. If the verbosity or the TTFT is a problem, keep it for batch jobs where latency is less critical.
If you are already automating with AI agents and want to see how teams that succeeded (and failed) approached their projects, our 7 lessons from real AI automation projects is a good companion read. And if you want to understand how a team of AI agents works together day-to-day in a shared-memory setup, the Agent OS daily operations playbook covers the operational side.
FAQ
Q: What is Ling 3.0 Tiny?
A: Ling 3.0 Tiny is a 7.9-billion-parameter Mixture-of-Experts model from InclusionAI (Ant Group's AI lab), released August 6, 2026. Only 1.3 billion parameters activate per token. It supports a 262K context window, native function calling, switchable Thinking/Instant modes, and is designed for responsive agents and edge deployment.
Q: How much does Ling 3.0 Tiny cost?
A: As of August 9, 2026, Ling 3.0 Tiny is free through OpenRouter (inclusionai/ling-3.0-tiny:free) and free through Vercel AI Gateway until August 14, 2026 at 8am PT. Post-promo pricing has not yet been published. OpenRouter's free tier has a roughly 200 requests/day limit.
Q: Can you run Ling 3.0 Tiny locally?
A: Not yet. InclusionAI has announced open weights are coming soon, but as of August 9, 2026, no weights or model card have been published on Hugging Face. The model is proprietary and available only through hosted APIs (OpenRouter and Vercel AI Gateway, both served by Novita).
Q: How does Ling 3.0 Tiny score on benchmarks?
A: Ling 3.0 Tiny scores 25 on the Artificial Analysis Intelligence Index (v4.1.1), ranking #6 of 56 models in its class — well above the class median of 8. It generates output at 184.1 tokens/second with a 1.86-second time-to-first-token. The index incorporates 9 evaluations including GPQA Diamond, Humanity's Last Exam, and Terminal-Bench v2.1.
Q: Does Ling 3.0 Tiny support function calling?
A: Yes. Ling 3.0 Tiny has native function calling (tool calling) support, meaning the model can trigger external tools and APIs as part of an agent loop. It also supports prompt caching and streaming. It does not support structured output (JSON-schema-constrained decoding) as of August 2026.
Q: How is Ling 3.0 Tiny different from Ling 3.0 Flash?
A: Ling 3.0 Flash is the larger sibling: 124 billion total parameters with 5.1 billion active per token, designed for high-throughput production use with peak speeds up to 1,000 tokens/second. Ling 3.0 Tiny is the edge-deployable model: 7.9 billion total with 1.3 billion active, built for on-device deployment, low-latency real-time interaction, and offline execution. Both share the 262K context window and MoE architecture.
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