Ling 3.0 Tiny: Ant Group's mini model runs on just 1.3 billion active parameters

InclusionAI, the AI arm of Alipay operator Ant Group, is now offering its smallest model, Ling 3.0 Tiny, on OpenRouter too – for a tiny $0.015 per million input tokens. According to the company, the 7.9-billion-parameter mixture-of-experts model can also run fully locally, and it can switch between a thinking mode and an instant mode.

Model releases Try it yourself Nov 5, 2026 6 min read Source: OpenRouter (neue Modelle)

The key points in brief

Ling 3.0 Tiny is a mixture-of-experts model with 7.9 billion parameters, of which only about 1.3 billion are active per token.
On OpenRouter it costs $0.015 per million input tokens and $0.045 per million output tokens, with a 262,000-token context window.
The model supports tool calling, structured outputs, and a switchable thinking mode ("Thinking") and instant mode ("Instant").
According to OrcaRouter, Artificial Analysis gives it a score of 23 on its Intelligence Index – 6th out of 56 in its class, where the class median is 8.
The model is very verbose: in the test run it generated about 210 million output tokens instead of the typical 63 million.
Ant Group markets it as a model that runs fully locally without the cloud; an OrcaRouter report, however, at one point described it as a proprietary model without open weights.

What's going on

InclusionAI, the AI team at China's Ant Group (operator of the Alipay payment service), has made its smallest language model, Ling 3.0 Tiny, available on OpenRouter. OpenRouter is an aggregator that lets you access hundreds of AI models from different providers through a single account and API. Ling 3.0 Tiny has been listed there since November 5, 2026, currently served by a single provider.

The model itself isn't brand new: according to OrcaRouter's blog, it first appeared on August 6, 2026, initially through Ant Group's own free endpoints. Ant Group officially positioned it at its Inclusion Conference on the Bund in Shanghai in September, where the company unveiled the entire Ling 3.0 family. Within that lineup, Ling 3.0 Tiny is the model for resource-constrained devices – according to the press release, it "runs fully locally with no cloud dependency" and is suited to personal knowledge management and offline tasks.

Small, but built as a mixture of experts

Ling 3.0 Tiny has 7.9 billion parameters in total but uses only about 1.3 billion of them for each token it processes. That's thanks to its mixture-of-experts (MoE) architecture: the model consists of many specialized sub-networks ("experts"), and for each word a kind of router picks only the relevant ones. Think of a large company where not every request goes through every department, only the ones responsible. The result: the model has the knowledge of an 8-billion-parameter model but computes roughly as fast as one with just over a billion parameters.

Ant Group calls it a "native hybrid reasoning model." That means you can switch per request between a thinking mode, where the model first reasons step by step internally before answering, and an instant mode that answers directly. According to OrcaRouter, thinking mode is on by default.

More key specs, according to OpenRouter and OrcaRouter:

Context window: 262,000 tokens (Ant Group says 256K) – so the model can take very long texts into account at once, such as entire books or long chat histories.
Output: up to 32,000 tokens per response.
Features: tool calling (the model can drive external tools such as search or a calculator), structured outputs (e.g., clean JSON for programs), and prompt caching.
Text only: the model doesn't understand images or audio.

According to OpenRouter, it's designed for "responsive agents, instruction following, and multi-turn conversations."

Pricing and performance

Metric	Value
Input price (OpenRouter)	$0.015 per 1M tokens
Output price (OpenRouter)	$0.045 per 1M tokens
Throughput	approx. 52 tokens/second
Latency to first token	approx. 1.04 seconds
Context	262K tokens
Artificial Analysis Intelligence Index	23 (6th of 56, class median 8)

The prices are extremely low. For comparison: OrcaRouter cited $0.06 and $0.18 on another gateway after a free period ended in August – OpenRouter now charges a quarter of that. One catch for European users: according to OpenRouter, the model isn't currently available via EU routing, which keeps requests processed inside the EU.

There is one independent performance measurement: according to OrcaRouter, benchmarking platform Artificial Analysis gives Ling 3.0 Tiny a score of 23 on its Intelligence Index, a composite of many tests. That's good for 6th place among 56 models in the same size class – where the median is just 8. For such a small model, that's strong. For comparison, OrcaRouter points to Inkling Small from Thinking Machines Lab, which scores 40 – but at 276 billion parameters, that's a completely different weight class.

One important caveat: Ling 3.0 Tiny is very chatty. In Artificial Analysis's test run, it generated about 210 million output tokens, versus a median of 63 million – more than three times as many. OrcaRouter calls this a "verbosity tax": the low per-token price is less of a bargain when the model produces far more tokens. Run locally, it means longer waits.

Open weights or not? Conflicting information

The sources contradict each other on one point. OrcaRouter describes Ling 3.0 Tiny as a "proprietary" model that exists only as an API, with no downloadable weights. Ant Group itself, on the other hand, explicitly advertises that the model runs fully locally without the cloud, and the OpenRouter page links to "Model weights." The most plausible explanation is that the weights were released some time after the initial launch in August – Ant Group has explicitly published other Ling 3.0 models, such as Ling-3.0-flash-Fin, on Hugging Face and ModelScope. If you want to run the model locally, check the license and the exact download source on Hugging Face yourself, though; our sources don't mention the license.

The Ling 3.0 family at a glance

Tiny is the smallest member of a whole lineup that Ant Group introduced in September:

Ling-3.0-flash: MoE model with 124 billion parameters, 5.1 billion active, for agents in production. According to the company, comparable to trillion-parameter flagships on most benchmarks.
Ling-3.0-flash-Fin: finance variant developed together with financial institutions, with open weights. Specializes in research, valuation models in Excel, and reports. Alongside it, Ant Group released the FinFIRST benchmark with 123 tasks written by experts from investment bank CICC.
Ling-3.0-flash-VL: image and video understanding with 1 million tokens of context.
Ling-3.0-flash-Santé: variant for medicine and life sciences.

What you need to try it

On OpenRouter, all you need is an account with a bit of credit – at these prices, the cost is negligible. For running it locally, the model is undemanding thanks to its size: with 4-bit quantization (the model's numbers are stored at lower precision so it needs less memory), it takes about 5 to 6 GB of VRAM (video memory), so a mid-range graphics card with 8 GB will do. Because only 1.3 billion parameters do the work per token, it still runs smoothly on a regular CPU with 16 GB of RAM, and well on Apple silicon Macs with 16 GB or more. On disk, it takes up roughly 5 to 16 GB depending on the variant. Heads up: if you use the full context window, you'll need considerably more memory.

The bigger picture

Ling 3.0 Tiny fits a clear trend: small MoE models that run on laptops yet can still use tools and reason. With 23 index points, it sits far above the average for its class – but it's no replacement for large models, and it only understands text. It's interesting for tinkerers who want to build local agents or a private assistant; for businesses, the rock-bottom price on OpenRouter is the draw. The downsides are its heavy verbosity, the unclear licensing situation, and the fact that the performance claims – apart from Artificial Analysis – come from the company itself.

Terms explained simply

Mixture of experts (MoE): An architecture in which a model consists of many specialized sub-networks, only a few of which work on each word. This makes it faster than its total size would suggest.
Hybrid reasoning: The model can either reason internally first (Thinking) or answer right away (Instant). Reasoning takes time but produces better results on tricky tasks.
Context window: The amount of text a model can keep in view at once. 262,000 tokens is roughly a thick book.
Tool calling: The model can call external tools such as web search, a calculator, or a database instead of guessing everything on its own.
OpenRouter: A service that lets you use many AI models from different providers through one account and one API.
Artificial Analysis Intelligence Index: An independent composite score that rolls the results of many tests into a single number to make models comparable.
Quantization: Shrinking a model by storing its numbers at lower precision. It then needs less memory but becomes slightly less accurate.

Sources

OpenRouter (neue Modelle) openrouter.ai
afp.com afp.com
orcarouter.ai orcarouter.ai
cna.com.tw cna.com.tw

#ant group#inclusionai#ling#moe#small models#openrouter

Read the original source

Try it yourself: Ling 3.0 Tiny

Explained step by step, no prior knowledge needed – on your own computer or free in your browser.

What can I do with it?

Ling 3.0 Tiny is a small text model you can run on an ordinary computer that can still reason. You can chat with it, summarize texts, draft emails, ask questions about long documents, or build it into agents that use tools such as search or databases. Thanks to its switchable thinking mode, it can work through logic and math problems step by step or answer simple questions instantly. Because only 1.3 billion of its 7.9 billion parameters work on each word, it's fast even without a powerful graphics card. On Artificial Analysis's independent index, it scores 23, far above the average for its size class (median 8). Limitations: it doesn't understand images or audio, it's clearly weaker than large models like Inkling Small (40 points), and it tends to write very long answers.

Who is it worth it for?

Worth it for anyone who wants a private assistant that works offline on a laptop or mid-range PC, and for tinkerers building local agents with tool calling. Less suitable if you need to analyze images or want top-tier quality for complex coding and specialist knowledge – larger models are clearly better there.

Ideas: What you can do with it

Private note-taking assistant

Paste in meeting notes, articles, or your own notes and have the model turn them into summaries, to-do lists, or bullet points. Since it runs locally, your data never leaves your machine – ideal for the personal knowledge management Ant Group explicitly pitches it for.

Offline help on the road

Install the model on your laptop and use it on a train or plane without internet, for example to draft texts, translate short passages, or explain terms. The light compute load also goes easy on your battery.

Small agent for your home server

Connect the model to scripts via tool calling, for example to query a calendar or a local database. The result is a simple assistant that can answer questions like "What's on tomorrow?" on its own.

Extracting data from text

Have the model convert invoices, emails, or form text into clean JSON, for example with name, date, and amount. You can feed the result straight into a spreadsheet or program.

Tutoring with worked solutions

Pose math or logic problems in thinking mode and have it explain the solution. That's great for practice, but double-check the results on harder problems.

Size7.9 B parameters (1.3 billion active)

Download4.8 GB (about 6 min at 100 Mbit/s)

Licensemit

TypeLanguage model (text chat)

Hugging FaceinclusionAI/Ling-3.0-tiny

What your computer needs

Graphics card (NVIDIA), fully in VRAM at least 4.5 GB VRAM, recommended 6.5 GBe.g. RTX 3060 Ti, RTX 4060, RTX 5060, RX 7600

Mac (Apple Silicon M1–M5) from 16 GB unified memoryThe GPU and CPU share the memory – the model can use about 70% of it

CPU only (no graphics card) Runs smoothly without a graphics cardan estimated 29 words per second on a current desktop PC (MoE: only 1.3 billion parameters active per word). This requires at least 16 GB of RAM.

Storage approx. 6.8 GB freeModel download plus programs

Google Colab runs for freeThe free Tesla T4 GPU with 15 GB is enough

Which variant is right for me?

Many models come in several sizes or "quantizations." These are compressed versions: smaller and faster, but slightly less accurate. Rule of thumb: pick the largest variant whose memory requirement fits in your VRAM (video memory). The scripts below choose this for you automatically.

Variant	Download	Needs approx.	Compatible graphics cards
`Q2_K`	3 GB	4.5 GB	e.g. RTX 2060, RTX 3050 8 GB, RX 6600
`Q3_K_M`	3.8 GB	5.5 GB	e.g. RTX 2060, RTX 3050 8 GB, RX 6600
`Q4_K_M` Default	4.8 GB	6.5 GB	e.g. RTX 3060 Ti, RTX 4060, RTX 5060, RX 7600
`Q5_K_M`	5.6 GB	7.5 GB	e.g. RTX 3060 Ti, RTX 4060, RTX 5060, RX 7600
`Q6_K`	6.5 GB	8.5 GB	e.g. RTX 3060 12 GB, RTX 4070, RTX 5070, RX 7700 XT
`Q8_0`	8.4 GB	10 GB	e.g. RTX 3060 12 GB, RTX 4070, RTX 5070, RX 7700 XT
`BF16`	16 GB	18 GB	e.g. RTX 3090, RTX 4090, Tesla P40

There's only one size (7.9B parameters, 1.3B active). With 8 GB of VRAM or 16 GB of RAM, go for a 4-bit variant (approx. 5–6 GB). With 12–16 GB of VRAM or a Mac with 16–32 GB, an 8-bit variant (approx. 9 GB) is worth it for slightly better quality. Full precision (approx. 16 GB) offers hardly any noticeable benefit for everyday use. The sources don't say whether ready-made GGUF files exist – check Hugging Face.

At 4-bit, the model needs about 5–6 GB of VRAM – an 8 GB card is enough.
With only 1.3B active parameters, it still runs reasonably fast on the CPU alone with 16 GB of RAM.
Macs with Apple silicon and at least 16 GB of unified memory are a good fit.
The context window of up to 262,000 tokens costs a lot of extra memory – locally, it's better to set 8,000 to 32,000 tokens.
Plan for about 5 GB (4-bit) to 16 GB (full precision) of disk space.

How do I find out what my computer has?

Windows: Press Ctrl + Shift + Esc → Task Manager → Performance tab → click GPU on the left. At the bottom you'll see Dedicated GPU memory (that's your VRAM). You'll find system memory under Memory.
Mac: Apple menu at the top left → About This Mac. You'll see your chip (e.g. M2) and memory (e.g. 16 GB). On Apple chips, graphics and processor share this memory.
Linux: Type nvidia-smi in the terminal (shows your graphics card and its memory) and free -h for system memory.

Guide

Google Colab (in your browser, no installation)

Google Colab is a free service from Google. It gives you a computer with a graphics card in your browser for a few hours. All you need is a Google account. For this model: runs for free – The free Tesla T4 GPU with 15 GB is enough.

Download the notebook. Click the button and save the file.
Download colab.ipynb
Open Colab. Go to colab.research.google.com and sign in with your Google account.
Upload the notebook. In the window that appears, click Upload on the left (or choose File → Upload notebook at the top) and select the file colab.ipynb.
Turn on the GPU. In the top menu, go to Runtime → Change runtime type → under Hardware accelerator, select T4 GPU → Save.
Start everything. Runtime → Run all (keyboard shortcut Ctrl + F9). If you see the warning “This notebook was not authored by Google,” click Run anyway.
Wait. The cells run one after another. A green checkmark appears to the left of each cell when it's done. Installation and download take about 6 minutes here.
Try it out. The result appears below the last cell. To test something else, change the text in the cell and run it again with Shift + Enter. The last cell starts a proper chat with an input field.
Clean up. When you're done: Runtime → Disconnect and delete runtime. This saves your free quota.

Good to know: The free GPU is limited (usually a few hours per day). After about 90 minutes of inactivity, Colab disconnects, and you'll have to start everything over.

Windows 10 / 11

The easiest way is Ollama, a free program that launches AI models with a single command.

Update your graphics driver (NVIDIA cards only): Install the NVIDIA app or the latest driver. For AMD cards, use the latest Adrenalin driver.
Install Ollama. Download the file OllamaSetup.exe from ollama.com/download/windows, double-click it, and choose Install. Afterward, a small llama icon appears in the taskbar at the bottom right.
Open a terminal window. Press the Windows key, type PowerShell and press Enter. A blue or black window opens.
Start the model. Copy this command ("Copy" button), paste it into the window with a right-click, and press Enter:
```
ollama run hf.co/bloomer010/Ling-3.0-tiny-GGUF:Q4_K_M
```
The first time, Ollama downloads the model (4.8 GB (about 6 min at 100 Mbit/s)). After that, it's instant.
Start typing. Once >>> Send a message appears, type your question and press Enter. Type /bye to end the chat.

Not enough memory? Pick a smaller variant from the table above, e.g. ollama run hf.co/bloomer010/Ling-3.0-tiny-GGUF:Q2_K.

Prefer automatic? A script that picks the right variant for you

Download both files into the same folder: try_windows.ps1 demo.py
Open the folder in File Explorer, right-click an empty spot and choose Open in Terminal.

Paste this command and press Enter:

powershell -ExecutionPolicy Bypass -File try_windows.ps1

If needed, the script installs Ollama via winget, measures your VRAM (video memory) and downloads the matching variant.

macOS

Macs with an Apple chip (M1 to M5) are ideal. Older Intel Macs are very slow.

Install Ollama. Download it from ollama.com/download/mac, open the file, and drag Ollama into your Applications folder. Launch Ollama once – a llama appears in the menu bar at the top.
Open Terminal. Press Cmd + Space, type Terminal, and press Enter.
Start the model. Paste the command (Cmd + V) and press Enter:
```
ollama run hf.co/bloomer010/Ling-3.0-tiny-GGUF:Q4_K_M
```
The first time, the model is downloaded (4.8 GB (about 6 min at 100 Mbit/s)).
Start typing. Type your question and press Enter. Quit with /bye.

Pick the right variant automatically

try_mac.sh

cd ~/Downloads
bash try_mac.sh

Linux

Check your GPU. nvidia-smi should show your card. If it doesn't, install the driver on Ubuntu and restart:
```
sudo ubuntu-drivers install
```

Install Ollama:

curl -fsSL https://ollama.com/install.sh | sh

Start the model:
```
ollama run hf.co/bloomer010/Ling-3.0-tiny-GGUF:Q4_K_M
```
Exit with /bye. Use ollama ps to check whether the model is running on the GPU.

Or let it pick the right variant automatically:

try_linux.sh

bash try_linux.sh
# mit Python/transformers statt Ollama:
MODE=hf bash try_linux.sh

Try it

Explain in three sentences what inflation is.

Summarize the following text in five bullet points: [insert text]

A train leaves Hamburg at 9:40 a.m. and takes 1 hour 55 minutes to reach Berlin. A disruption adds 23 minutes. When does it arrive? Think step by step.

Write a friendly but firm email to my landlord saying the heating has been broken for a week.

Return the data from this sentence as JSON with the fields name, date, and amount: "Anna Schmidt transferred €249.90 on May 3."

Tips for better results

Use instant mode for chats, summaries, and rewording, and turn on thinking only for math, logic, and planning tasks.
Cap the maximum response length so the very talkative model doesn't ramble, and explicitly ask for short answers in your prompt.
For programs and automations, structured output pays off: specify an exact JSON format and the model will stick to it more reliably.
For agent tasks, provide clear, concise tool descriptions – small models benefit greatly from unambiguous instructions.
Fact-check its output: with 7.9B parameters, its world knowledge is limited; it works better with texts you supply yourself.

If something goes wrong

The information on open weights is contradictory: Ant Group advertises local use, while one report at one point called it proprietary. Before downloading, check on Hugging Face whether the weights are available and under what license.

New MoE architectures are often only supported by recent versions of llama.cpp, Ollama, or LM Studio – if you get loading errors, update the app first.

Thinking mode is on by default and the model is very verbose (roughly three times as many output tokens as usual) – so responses take longer locally. Use instant mode for simple tasks.

If you max out the large context window, you'll quickly hit out-of-memory errors – deliberately limit the context length in the settings.

On OpenRouter, the model currently isn't available via EU routing; if you need to keep data in the EU, run it locally.

“out of memory,” a crash, or your computer freezes

The model is too big for your VRAM (video memory). Pick a smaller variant from the table above and close other programs, especially games and browsers with lots of tabs.

It runs, but extremely slowly

Your CPU is probably doing the work instead of your graphics card. In Ollama, the PROCESSOR column of ollama ps shows how much runs on the GPU. If it says "100% CPU", update your graphics driver or pick a smaller variant that fits entirely into VRAM (video memory).

“ollama” or “python” is not found

Close the terminal window and open it again so it recognizes the newly installed program. For Python on Windows: reinstall it and check Add python.exe to PATH.

Windows: "Running scripts is disabled on this system"

Run the script with exactly the command above: powershell -ExecutionPolicy Bypass -File try_windows.ps1. This allows execution for this one time only.

Error message when loading the model (version, "trust_remote_code", unknown architecture)

Brand-new models often need the latest software version. With Ollama: update Ollama. With Python: pip install -U transformers in the activated environment. The Model Card usually lists the exact version.

Tokenstrom generates the scripts and notebook automatically. Please take a quick look before running them – they're plain, readable text. Mind the model's license: mit.

Ask the AI assistant

Questions about this article, installation or background? Our assistant knows this page and runs on our own machine, not in someone else's cloud.

Connecting …

The Assistant is an AI (Gemma 4) and can make mistakes – please check important details against the source. Questions are used only to generate an answer and are deleted after one hour. Please don't enter any personal data.

Comments

What do you think? Already tried it? Write it here, no sign-up needed.

Loading comments …

Comments are public. Links aren't allowed, and we delete abusive posts. You can delete your own comment at any time in this browser. Learn more in the Privacy Policy.