Ling-3.0-flash-Sante: inclusionAI releases open 124B medical model

inclusionAI, Ant Group's AI lab, has released Ling-3.0-flash-Sante, an open-weights model specialized for health and medicine. It has 124 billion parameters but uses only 5.1 billion per token, and it can handle up to 256K tokens of context. It is explicitly a research model, not a medical device.

Model releases Try it yourself Oct 22, 2026 5 min read Source: r/LocalLLaMA

The key points in brief

Ling-3.0-flash-Sante is built on Ling-3.0-flash and has 124B parameters, of which 5.1B are active per token.
According to the Model Card, the weights are on Hugging Face and ModelScope; the architecture combines Kimi Delta Attention (KDA), gated MLA and sparse MoE layers.
Training extends to 256K tokens of context; thinking mode is on by default, and tool calls are supported through compatible serving frameworks.
The guide lists four 141 GB-class GPUs or eight 80 GB GPUs (H100/H800) for running it with SGLang or vLLM.
According to Ant (vendor figures, reported by a third-party source), Sante scores 83.8 on DiagnosisArena-MCQ but only 53.9 on MedXpertQA-Text.
The vendor stresses: research model, not a medical device; outputs can be wrong and are no substitute for medical advice.

What this is about

inclusionAI, the AI lab of Ant Group, has released Ling-3.0-flash-Sante. It is a health- and medicine-specialized variant of the general-purpose Ling-3.0-flash model. The name comes from the French word santé ("health"). According to the Model Card and a Reddit post, the weights are available on Hugging Face and ModelScope, so you can download the model and run it yourself. It is designed for medical reasoning, health research, "deep research" (multi-step research with source analysis) and tool-based workflows, while keeping the general capabilities of the base model.

One important point up front: the vendor calls Sante a research model, not a medical device. Its outputs may be incomplete or wrong and must not replace professional advice, diagnosis or treatment.

Architecture: big, but frugal at runtime

Sante has 124 billion parameters (roughly, the knobs the model tuned during training). It is a Mixture-of-Experts (MoE) model: instead of using all parameters for every word, only a subset of specialized "experts" is activated. Here, that's 5.1 billion per token. This makes computation faster and cheaper than with a "dense" model of the same size. Memory, however, still has to hold all 124 billion parameters.

The architecture is a "hybrid-linear" design built from three components:

Kimi Delta Attention (KDA): an attention variant whose cost grows more slowly with long texts.
Gated MLA: a memory-efficient form of attention.
Sparse MoE layers: the experts described above.

Training extends to 256K tokens of context (a token is roughly a word fragment). That lets you analyze long documents, such as several study protocols. Thinking mode is on by default and can be switched off per request via chat_template_kwargs with enable_thinking: false.

What the model is meant to do

According to the Model Card, Sante was tested on professional health tasks, medical knowledge and safety, complex reasoning, deep research, multi-agent collaboration and tool-assisted agent tasks. The listed use cases:

answering medical questions, with human review
literature search, evidence summarization, scientific research
long-document analysis and structured information extraction
knowledge bases and retrieval-augmented generation (RAG), meaning answers based on documents looked up at query time
multi-agent workflows and building domain-specific AI agents

About the test conditions: temperature 1.0 and top_p 0.95, with the highest thinking level for all compared models. On BrowseComp (a web research test), 256K context and up to 1,000 turns were used. In the multi-agent setting, an in-house system distributes tasks to up to 64 sub-agents. The Model Card provides its results table only as an image, so we don't have all the individual values.

Numbers from a third-party source

A blog from routing provider OrcaRouter cites Ant's own figures (vendor claims, not independently verified):

Benchmark	Sante	Comparison
DiagnosisArena-MCQ	83.8	GPT-5.6 Sol 81.9; Kimi K3 78.4; Gemini 3.6 Flash 76.2
MedXpertQA-Text	53.9	GPT-5.6 Sol 60.2; Gemini 3.6 Flash 62.4

So Sante leads on one test and trails on the other. The blog also criticizes the missing comparison with its own base model, Ling-3.0-flash, which leaves open how much the medical tuning actually adds. The blog further claims that no Sante weights have been published. That contradicts the Model Card and the Reddit post, and likely reflects an earlier state of affairs (back then, Sante was available only via API, free during a promotional period). We go with the Model Card.

What you need to try it

This is not a model for a regular home PC. For 256K context, the official guide calls for four 141 GB-class GPUs (or a Blackwell node with four GPUs) or eight 80 GB GPUs such as H100/H800. Even with heavy quantization (storing weights in fewer bits), you need roughly 75 GB or more of memory for the weights alone. Running it on a Mac with a lot of unified memory or on a CPU is theoretically possible, but our source says nothing about it, and it doesn't mention GGUF versions. In practice, that leaves rented cloud GPUs. Also plan for several hundred GB of disk space.

Our take

Sante is another example of "specialists on a generalist frame": a large, efficient MoE model post-trained for one field. What's interesting is the open weights, the 256K context length, and the focus on research and agents rather than just quiz questions. The caveats: all benchmark figures are vendor claims, the comparison with the base model is missing, and the results are mixed. The Model Card itself warns that benchmarks don't guarantee clinical performance, that the model must not independently diagnose, prescribe or triage, and that tool and multi-agent access require minimal permissions and human approval. Our source doesn't state Sante's license (according to a third-party source, the base model is MIT-licensed), so check the license on Hugging Face before using it. For researchers and developers of medical agents, the model is an exciting candidate to test. For patients, it is explicitly not intended.

Terms explained simply

Mixture-of-Experts (MoE): A model made up of many specialized sub-networks ("experts"), only a few of which are active per token. This saves compute.
Active parameters: The share of parameters that actually compute for a single token. Here, 5.1 of 124 billion.
Context window: The amount of text the model can hold "in mind" at once, up to 256K tokens here.
Kimi Delta Attention (KDA): An attention variant that needs less compute and memory on long texts than classic attention.
Deep Research: Multi-step research in which the model searches, reads and combines findings into an answer on its own.
RAG: Retrieval-Augmented Generation: the model receives matching documents from a database and answers based on them.
Tensor parallelism: A large model is split across several GPUs that compute together (parameter --tp).

Sources

r/LocalLLaMA reddit.com

#medicine#open-weights#moe#inclusionai#agents

Read the original source

Try it yourself: Ling-3.0-flash-Sante

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

What can I do with it?

The model answers specialist medical questions, summarizes studies and clinical abstracts, compares protocols, and can work as a research agent with tools. It thinks step by step by default and handles very long documents.

Who is it worth it for?

Worth it for researchers, developers of medical agents and teams with access to multi-GPU servers. Not for laypeople looking for health advice, and not for single-GPU machines.

Size124 B parameters (5.1 billion active)

Download136 GB (about 3.0 hr at 100 Mbit/s)

Licensemit

TypeLanguage model (text chat)

Hugging FaceinclusionAI/Ling-3.0-flash-Sante

What your computer needs

Graphics card (NVIDIA), fully in VRAM at least 123 GB VRAM, recommended 152 GBservers only, with multiple data-center GPUs (e.g. 8× H100) – fastest; with less VRAM, see the next line

Graphics card + system memory (MoE offloading) from approx. 6 GB VRAM + 256 GB RAMdie Experten liegen im Arbeitsspeicher, nur der Kern auf der Grafikkarte (llama.cpp/LM Studio). Langsamer als komplett im VRAM, aber auf normalen PCs machbar

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

CPU only (no graphics card) Usable without a graphics card, but you'll need some patiencean estimated 7 words per second on a current desktop PC (MoE: only 5.1 billion parameters active per word). This requires at least 256 GB of RAM.

Storage approx. 138 GB freeModel download plus programs

Google Colab too big for Colabeven the largest Colab GPUs aren't 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
`Q6_K`	111 GB	123 GB	servers only, with multiple data-center GPUs (e.g. 8× H100)
`Q8_0` Default	136 GB	152 GB	servers only, with multiple data-center GPUs (e.g. 8× H100)

According to the source, Ling-3.0-flash-Sante comes in one version. The recommended setups are 4×141 GB GPUs (--tp 4) or 8×80 GB GPUs (--tp 8). The source doesn't mention quantized variants (e.g., GGUF).

For 256K context: four 141 GB GPUs or a Blackwell node with four GPUs.
On 80 GB GPUs (H100/H800), use --tp 8 with the same settings.
All 124B parameters must fit in memory, even though only 5.1B are active per token.
Long contexts cost extra memory; a shorter --context-length reduces the requirement.
The source gives no information for consumer GPUs, CPU or Apple Silicon (VRAM figures for those are not given).

Groß (124 B parameters, MoE): running entirely on the GPU takes a lot of VRAM (video memory). With MoE offloading, a regular graphics card plus plenty of RAM is enough (see table). Colab Free isn't enough.

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: too big for Colab – even the largest Colab GPUs aren't 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 (with Colab Pro: L4 or A100) → 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 49 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/AtomicChat/Ling-3.0-flash-Sante-GGUF:Q8_0
```
The first time, Ollama downloads the model (136 GB (about 3.0 hr 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/AtomicChat/Ling-3.0-flash-Sante-GGUF:Q6_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/AtomicChat/Ling-3.0-flash-Sante-GGUF:Q8_0
```
The first time, the model is downloaded (136 GB (about 3.0 hr 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/AtomicChat/Ling-3.0-flash-Sante-GGUF:Q8_0
```
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

Summarize the evidence in this clinical abstract and name the primary endpoint.

Compare the inclusion criteria of these two study protocols in a table.

What interactions and contraindications of taking warfarin and ibuprofen together are known from the literature? Point out uncertainties.

If something goes wrong

For SGLang, use the special image lmsysorg/sglang:dev-Ling-3.0-flash; a standard image may not recognize the architecture.

vLLM needs a recent build with Ling-3.0 support (install from the Git repository), plus --trust-remote-code and the ling3 parsers.

With 256K context in SGLang, set the variable SGLANG_ALLOW_OVERWRITE_LONGER_CONTEXT_LEN=1 and give it enough shared memory (--shm-size 32g).

A Hugging Face token (HF_TOKEN) may be required.

Never use outputs unchecked: the model can hallucinate and is not a medical device.

“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.