Baidu quietly drops ERNIE 5.5 Flash Base, a 280B open-weight MoE model

Baidu has put its new base model, ERNIE 5.5 Flash Base, on Hugging Face with little fanfare. The MoE model has 280 billion parameters, but only 14 billion are active per token. In Baidu's own tests, it beats similarly sized rivals from DeepSeek, Tencent and Xiaomi. Don't expect a chatbot, though: this is a raw model for developers.

Model releases Try it yourself Nov 5, 2026 6 min read Source: Reddit r/LocalLLaMA
Illustrative image, AI-generated

What's happening

Chinese search and AI giant Baidu released its new language model ERNIE 5.5 Flash Base (Chinese: 文心5.5 Flash Base) as an open-weight model on November 5, 2026. The weights are freely available on Hugging Face under baidu/ERNIE-5.5-Flash-Base, and there's a release page on ernie.baidu.com. As with many Chinese releases, the model showed up before the explanation. According to an analysis by API provider OrcaRouter, the repository was created back on October 21. Between November 2 and 3, 128 weight files in FP8 format were added, followed on November 4 by the architecture and benchmark charts. There was no press release and no launch event.

The key word is "Base": this is a base model, meaning the state right after pretraining. It hasn't yet been trained to follow instructions or chat. It continues existing text, much like your phone's autocomplete, only far more capable. It's aimed at developers and companies that want to build their own specialized models on top of it.

The specs

ERNIE 5.5 Flash Base uses a Mixture-of-Experts (MoE) architecture. The model consists of many specialized subnetworks, the "experts." For each word, only a small selection of them is consulted, a bit like a large hospital where not every doctor sees every patient. According to Baidu and OrcaRouter:

Spec Value
Total parameters 280B
Active per token 14B
Training data 33.5 trillion tokens, trained from scratch
Layers 43 (1 dense FFN layer, 42 MoE layers)
Experts 512, with 10 active per token, plus 1 shared expert
Vocabulary 201,216 tokens
Context Trained up to 128K (131,072), configured up to 1,048,576 tokens
Languages/modality Text only, English and Chinese
Formats FP8 and BF16

The context is the amount of text the model can take in at once. A million tokens is roughly several thick books. During training, though, the model only saw 128,000 tokens. The longer length is intended for fine-tuning and inference, and whether it holds up in practice remains to be seen.

What's new under the hood

According to Chinese tech outlet Leiphone, the design centers on efficiency. The longer the text, the more compute and VRAM it eats. Baidu cites several in-house techniques:

  • Latent-Gated Sparse Attention: Attention is the mechanism the model uses to decide which earlier parts of the text matter right now. Baidu combines two variants: 37 layers with heavily compressed attention (HCA) that summarize the history, and 6 layers with MLA and sparse attention that pinpoint specific earlier positions. On top of that comes "Low-Rank Gated Attention." It reuses existing compressed intermediate values and so cuts 75 percent of the weights for the so-called gate projection. "Virtual Head Attention" is meant to improve quality while adding barely any compute at inference time.
  • Multi-Router Latent MoE: Normally, a single "router" picks which experts get used. In ERNIE, several independent routers decide together. The idea is that a single misjudgment carries less weight, while compute and communication costs stay the same.
  • ECHO: Many models learn to predict several tokens ahead using an extra module (Multi-Token Prediction, MTP). According to Leiphone, Baidu instead uses the model's own final layer for this. It's meant to help with planning and thus mainly improve reasoning and coding tasks. The same layer can also serve as a draft model for speculative decoding: a fast helper proposes several words, and the big model just checks them. That speeds up output. OrcaRouter, however, also mentions a 0.36B-parameter MTP head that isn't included in any of the parameter counts. The sources don't make clear exactly how these fit together.
  • Training infrastructure: Baidu also reworked the distributed Muon optimizer, a method that adjusts the weights during training, and added a new attention kernel called FlashMask-4.

Benchmarks: strong, but self-reported

Baidu compares its model with three similarly sized Chinese base models: DeepSeek-V4-Flash-Base (284B, 13B active), Tencent's Hy3-preview-Base (295B, 21B active) and Xiaomi's MiMo-V2.5-Base (310B, 15B active). According to OrcaRouter, ERNIE comes out ahead on 24 of 30 tests. A few examples:

Benchmark ERNIE 5.5 Flash Base Comparison score per OrcaRouter
MMLU-Pro (knowledge) 78.4 69.2
HumanEval+ (code) 82.3 69.5
RepoQA (code understanding) 91.7 81.0

ERNIE lost on ChineseSimpleQA, HELMET-Rerank and InfiniteBench against DeepSeek, among others, and on FullStackBench and BBH with chain of thought against Hy3. Other reported scores include MMLU 93.3, GPQA 60.2 (5-shot) and LiveCodeBench 40.1 (Pass@1).

OrcaRouter warns against apples-to-oranges comparisons. A LiveCodeBench score of 40.1 looks weak next to the 91.9 of Alibaba's finished model Qwen 3.8 Flash. But one is an untuned base model, the other a fully post-trained product, measured on a newer version of the benchmark to boot. Baidu's table is internally consistent, since all models were tested with the same prompts and settings. Nobody has independently verified it yet, though.

Availability, license and deployment

The weights are released under the "ERNIE 5.5 Flash Base Model License Agreement v1.0". It's a custom license that, according to OrcaRouter, you should read in full before any commercial use. There's no API yet: the price list for Qianfan, Baidu's cloud platform, doesn't include ERNIE 5.5. For deployment, Baidu ships ready-made recipes. One is an SGLang image (lmsysorg/sglang:dev-ernie-55-flash) with tensor parallelism 4, which splits the model across four GPUs. The other runs on vLLM 0.32.0 plus the baidu/vLLM-ERNIE plugin. You access it via a completions endpoint, not a chat interface.

What you need to try it

This model won't run on a regular PC. The FP8 weights alone take up roughly 280 GB, and BF16 about twice that. Baidu's official recipe spreads the model across four data-center GPUs. Even a 4-bit quantization, a slimmed-down version that stores numbers more coarsely, would need roughly 170 GB of VRAM. There are no known adapted versions for Mac or CPU such as GGUF yet, and no Ollama entry either. In theory, workstations with lots of RAM, say 256 GB or more, could run it once the community builds such versions. There are no concrete numbers on that yet. Google Colab won't cut it. Realistically, you can only use the model on rented cloud GPUs or your own servers.

The bottom line

ERNIE 5.5 Flash Base is yet another strong open-weight base model from China. It enters a crowded class of roughly 300B parameters with 13B to 21B active. It's mainly interesting for research teams and companies that want to fine-tune their own model and are looking for a capable, efficient foundation. The many disclosed architecture details are valuable to them, too. For end users, the model offers little for now: there's no chat version, no API and no version for home hardware. The benchmarks come exclusively from Baidu. Whether a post-trained version can keep up with models like Qwen 3.8 Flash or DeepSeek remains an open question.

Sources

#baidu#ernie#moe#open-weights#base model
Read the original source

Try it yourself: ERNIE-5.5-Flash-Base

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

What can I do with it?

ERNIE 5.5 Flash Base is a very large language model for English and Chinese that, according to Baidu's own tests, leads its size class. That's especially true for knowledge, math and code, e.g. HumanEval+ 82.3 and MMLU-Pro 78.4. Because it's a pure base model, it continues text instead of answering questions. Give it the start of a document, a function or a set of examples, and it keeps writing in the same style. Without your own fine-tuning, it won't work as a chatbot like ChatGPT. Its real strength is as a starting point for your own specialized models. Thanks to MoE, only 14B parameters are active per token. But you still have to store all 280B, so it needs server hardware. It doesn't understand images, audio or video.

Who is it worth it for?

The model is worth it for ML teams, researchers and companies with access to multi-GPU servers who want to fine-tune their own model or compare base models. It's not for beginners with a regular PC, Mac or gaming GPU. If you just want to chat, wait for an instruct version or use a smaller chat model.

Ideas: What you can do with it

Train your own domain model

A company fine-tunes the base model on its own documents, such as support tickets or technical manuals. The result is a specialized assistant that speaks the company's language, without training a model from scratch.

Code completion for your team

Running on an internal server, the model completes half-written functions based on their signature and comment. Strong scores on code benchmarks like RepoQA suggest it can also grasp larger code contexts.

English-Chinese translation by example

Given a few sentence pairs as a template, the model translates further sentences in the same style. That's useful for teams working with Chinese partners who want to keep texts on their own hardware.

Compare base models

Researchers can check Baidu's benchmark claims with their own tests and put the model side by side with DeepSeek-V4-Flash-Base or MiMo-V2.5-Base. That produces the independent numbers that are still missing.

Continue and summarize long documents

Thanks to the large context window, you can paste in long reports and have the model generate a continuation from a suitable opener like "Summary:". How well this works with very long texts is something you should test yourself.

Size286.2 B parameters (14 billion active)
Download172 GB (about 3.8 hr at 100 Mbit/s)
Licensecustom license (see Model Card)
TypeLanguage model (text chat)

What your computer needs

Graphics card (NVIDIA), fully in VRAM at least 190 GB VRAMservers 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. 8 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 512 GB unified memoryThe GPU and CPU share the memory – the model can use about 70% of it
CPU only (no graphics card) Very slow without a graphics cardan estimated 3 words per second on a current desktop PC (MoE: only 14 billion parameters active per word). This requires at least 256 GB of RAM.
Storage approx. 174 GB freeModel download plus programs
Google Colab too big for Colabeven the largest Colab GPUs aren't enough

Values estimated from the model size – the Model Card may have more precise figures.

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.

VariantDownloadNeeds approx.Compatible graphics cards
4-bit (Q4) Default 172 GB190 GBservers only, with multiple data-center GPUs (e.g. 8× H100)
8-bit (Q8) 306 GB338 GBservers only, with multiple data-center GPUs (e.g. 8× H100)
16-bit (Original) 572 GB631 GBservers only, with multiple data-center GPUs (e.g. 8× H100)

There are two official variants: FP8 (around 280 GB, recommended for running with Baidu's recipes) and BF16 (about twice the size, mainly useful as a starting point for fine-tuning). No quantized GGUF versions for llama.cpp or Ollama are known yet. A 4-bit version would need roughly 170 GB of memory.

  • Baidu's official SGLang recipe uses tensor parallelism 4, meaning four data-center GPUs with plenty of VRAM.
  • The FP8 weights alone take up about 280 GB; the BF16 variant needs roughly twice that much storage.
  • Even quantized to 4 bits, you'd need roughly 170 GB of VRAM or a comparable amount of fast RAM.
  • Very long contexts of up to 1M tokens require additional memory for the KV cache.
  • Running it meaningfully on consumer GPUs, Apple Silicon, CPUs alone or Google Colab isn't currently possible. Rented cloud GPUs are the realistic option.

Groß (286,2 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.

  1. Download the notebook. Click the button and save the file.

    Download colab.ipynb

  2. Open Colab. Go to colab.research.google.com and sign in with your Google account.
  3. 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.
  4. 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.
  5. Start everything. Runtime → Run all (keyboard shortcut Ctrl + F9). If you see the warning “This notebook was not authored by Google,” click Run anyway.
  6. 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 61 minutes here.
  7. 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.
  8. 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

This model runs on Python. Our script handles the setup automatically: it creates an isolated Python environment, installs the required packages (PyTorch, approx. 3 GB) and downloads the model (172 GB (about 3.8 hr at 100 Mbit/s)).

  1. Update your graphics driver (NVIDIA): install the latest driver. Without an NVIDIA card, it runs on the CPU – much more slowly.
  2. Install Python. Download Python 3.12 from python.org and run the installer. Important: At the bottom of the first window, tick Add python.exe to PATH, then click Install Now.
  3. Create a folder and download the files. Create a folder, e.g. Documents\AI-Test, and save both files into it:

    try_windows.ps1 demo.py

  4. Open a terminal in the folder. Open the folder in File Explorer, right-click an empty spot → Open in Terminal.
  5. Run it. Paste this command and press Enter:
    powershell -ExecutionPolicy Bypass -File try_windows.ps1
    Installation and download are running now. The first time, this can take 10–30 minutes.
  6. Result. The window shows the model's answer to a test question.
  7. Try your own input: Open demo.py in an editor, change the sample text, and save. Then run this in the terminal:
    .\.venv-ernie-5-5-flash-base\Scripts\Activate.ps1
    python demo.py

macOS

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

  1. Open Terminal. Press Cmd + Space, type Terminal, and press Enter.
  2. Install the developer tools (first time only; includes Python):
    xcode-select --install
    Click Install in the window. If you see "already installed," everything is already in place.
  3. Download the files – both end up in your Downloads folder:

    try_mac.sh demo.py

  4. Run it:
    cd ~/Downloads
    bash try_mac.sh
    The first time, installation and download take 10–30 minutes.
  5. Result. The window shows the model's answer to a test question.

Linux

  1. Check your GPU. nvidia-smi should show your card. If it doesn't, install the driver on Ubuntu and restart:
    sudo ubuntu-drivers install
  2. Install the Python basics (Ubuntu/Debian):
    sudo apt update && sudo apt install -y python3-venv python3-pip git
  3. Put the files in a folder and open a terminal there:

    try_linux.sh demo.py

  4. Run it:
    bash try_linux.sh
  5. Result. The window shows the model's answer to a test question.

Try it

The capital of France is Paris. The capital of Japan is Tokyo. The capital of Canada is
def is_prime(n: int) -> bool:
    """Returns True if n is a prime number."""
English: The weather is nice today.
Chinese: 今天天气很好。
English: I would like a cup of coffee.
Chinese:
Question: A train travels 120 km in 1.5 hours. What is its average speed?
Answer: 120 / 1.5 = 80 km/h.
Question: A cyclist rides 45 km in 2.5 hours. What is their average speed?
Answer:
Summary of the following contract text in three bullet points:
[long text]

Summary:
-

Tips for better results

  • Use few-shot prompts: two to five examples in the format you want steer a base model far more reliably than an instruction.
  • Set stop sequences, such as a line break or "Question:", so the model doesn't just keep writing after the answer.
  • For code completion, a function signature plus docstring works especially well as input, since that plays to its HumanEval+ strength.
  • If you want to fine-tune the model, start from the BF16 variant and use the FP8 variant for deployment later.
  • Test in English or Chinese first to gauge quality before trying other languages.

If something goes wrong

It's a base model: chat requests like "Explain to me …" work poorly. Use the completions endpoint (/v1/completions) and phrase your input as the start of a text or with examples.

vLLM requires version 0.32.0 plus the baidu/vLLM-ERNIE plugin. Without the plugin, the architecture isn't recognized.

SGLang requires the special image lmsysorg/sglang:dev-ernie-55-flash. The standard SGLang release may not support the model yet.

Read Baidu's custom license (ERNIE 5.5 Flash Base Model License Agreement v1.0) in full before any commercial use.

The model was trained with up to 128K tokens of context. The enabled million tokens shouldn't be taken as a quality guarantee.

Other languages, such as German, aren't officially supported; the model is focused on English and Chinese.

“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: custom license (see Model Card).

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.

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