Best open LLMs 2026: Qwen 3.8, DeepSeek V4, Kimi K3, GLM-5.3 and Muse Glimmer

Best open LLMs 2026: Qwen 3.8, DeepSeek V4, Kimi K3, GLM-5.3 and Muse Glimmer

Open weights means a company publishes the model itself: you can download it and run it on your own hardware without going through anybody's service.

Open weights means a company publishes the model itself: you can download it and run it on your own hardware without going through anybody's service.

Why that matters in practice: your data never leaves the building, nobody charges you per request, and the model cannot be withdrawn — it is already yours.

Below: how open weights differ from open source, five flagships compared by size and licence, what to pick for code, for text and for modest hardware, how to shrink a model to fit your machine, where the money is, and how to run one locally.

The figures come from model cards and official blogs. This is a living guide: the daily AI digests keep it current, and the Open Source tools catalogue sits alongside it.

---

The short version

"Open weights" and "open source" are not the same thing. You can download the model, but reproducing its training from scratch usually is not possible.

The main reason to take an open model is not saving money, it is the data. For companies with information requirements this is a condition of working at all, not an advantage.

The licence matters more than the ranking. The freest right now are Muse Glimmer (Apache 2.0), DeepSeek V4 and GLM-5.2 (MIT).

Size decides what you can actually run. A 27–30 billion model in compressed form needs around 16–20 GB of video memory; 7–8 billion fits in 8 GB.

Rankings cannot be trusted blindly. Flagships change almost weekly, and a benchmark measures its own task, not yours.

There is money here. A local model is the ticket in to clients who cannot let data leave the building. Such projects run $490–1 460.

---

Part 1. What open weights are

Open weights means access to the model itself, but not necessarily to everything it was made from.

Open source in the classical sense means everything is open: the training code, the data, and a licence permitting any use.

With most open models the model itself and the code to run it are published, while the training data and the full process are not. The licence sometimes carries restrictions.

Hence the correct term is "open-weight": you can download and run it, but as a rule you cannot repeat the training from scratch.

The difference shows in the licences

Some models ship under genuinely free licences — Apache 2.0, MIT. They can be used commercially with almost no conditions.

Others come under "community" licences with caveats: attribution requirements, a user-count threshold, regional clauses. That does not make them closed, but legally it is not the same thing, and for a business the difference matters.

Tellingly, the current generation has shifted towards freedom: Meta released the open Muse Glimmer 30B under Apache 2.0 for the first time, and DeepSeek publishes V4 under MIT. The most notable releases of 2026 came out not only stronger but legally cleaner.

Why bother instead of a convenient API

Three reasons.

Privacy and control. Data never goes to a third-party service, the model runs inside your perimeter, and its behaviour does not change without your knowledge at the next update.

Economics. At high volume, running it yourself often costs less than paying per unit, and the price is predictable — particularly given that even inexpensive APIs are getting dearer: DeepSeek raised its rates on 16 August 2026.

Independence. Open weights cannot be revoked or withdrawn from sale, so your product will not stop because of somebody else's decision.

The price is that you keep the hardware and the maintenance yourself. Which is exactly why the choice comes down to model size and licence.

---

Part 2. The flagships compared

Current models from five families. "Active parameters" are given for those split into parts — what that means is explained right under the table.

| Family | 2026 flagship | Size | Licence |

|---|---|---|---|

| Qwen (Alibaba) | Qwen 3.8 Max | 2.4T total / 95B active | read the card — there were questions about regional clauses |

| DeepSeek | DeepSeek V4 Pro | ~1.7T | MIT |

| Kimi (Moonshot AI) | Kimi K3 | 2.8T total / ~104B active | read the card |

| GLM (Z.ai) | GLM-5.2, 5.3 weights pending | — | MIT (5.2) |

| Meta (Muse) | Muse Glimmer 30B | 29.6B, dense | Apache 2.0 |

Sources: Qwen 3.8 Max — ModelScope and the Qwen3.8-27B card; DeepSeek V4 Pro — the Hugging Face card; Kimi K3 — the moonshotai organisation; GLM-5.3 — the Z.ai blog; Muse Glimmer 30B — the model card and NVIDIA's write-up.

Previous generations — Qwen3 under Apache 2.0, DeepSeek-V3, Kimi K2, GLM-4.6, Llama — still work but fall behind the current ones.

Two numbers instead of one: why

Some models in the table carry two sizes. Worth explaining, because whether it will run on your machine depends on it.

Such models are split into many expert parts, and only a small share of them switches on for each word.

Hence two figures:

Total size — what the model weighs and how much memory it needs simply to sit ready.

The active part — how much is actually computed per word, which determines speed and running cost.

An example: DeepSeek V4-Flash is 284 billion in total but only 13 billion active. Qwen 3.8 Max is 2.4 trillion with 95 billion active.

A large total gives a reserve of knowledge, a small active part gives acceptable speed. But the memory still has to cover the total.

The second thing people check after size

How much text the model holds at once — your request plus its answer.

For long documents, large projects and many-step chains this is critical: a small window forces you to cut the input into pieces and lose the thread.

The current generation raised the bar: DeepSeek V4-Flash holds a million words, and the cloud version of Qwen 3.8 27B roughly the same. But you pay for it in memory, so match it to the task rather than taking the maximum just in case.

---

Part 3. What to pick for your task

The choice comes down to three things: the task, your hardware, and the licence you can accept.

For code and agents

People take the large models with strong results on engineering tests: DeepSeek V4 Pro, Qwen 3.8 Max, GLM-5.3, Kimi K3.

The key practical criterion here is not only quality but the licence. DeepSeek publishes V4 Pro under MIT and GLM-5.2 is also MIT, which removes most legal questions for a product.

Recent measurements: DeepSeek V4 Pro's DeepSWE result rose from 12.8 to 62.7; GLM-5.3 lifted its Terminal-Bench 3.0 score from 4.6 to 28.3, and DeepSWE v1.1 from 46.2 to 66.9.

Alongside the model you usually need tools and a harness — ready processes are easiest to take from the automation templates section, and the knowledge of how to walk an agent through steps from the Skills for Claude Code hub.

And separately, the part most people are missing. A deployed model does nothing by itself — it answers requests. For it to work inside a process you need the wiring: what triggers it, where the result goes, what happens on failure.

For anyone deploying their own, that is usually the missing piece: the model is up and there is no process around it.

The express course "AI Agents: the electrification of routine" covers exactly this: from a first automatic agent to chains running round the clock. Inside are 20 finished projects and four platforms — Make, n8n, Relevance and Lindy.

n8n is particularly apt here: it is the only one of the four you can stand up on your own server next to a local model — and then the whole loop, from trigger to result, stays inside your perimeter.

$9, included in the Make and Team plans. Not included in the three free days of Basic.

For text across languages

Qwen 3.8 and DeepSeek V4: both trained on large multilingual sets and both handle dozens of languages confidently. That matters for localisation, supporting clients across markets, and translation.

Both come in a range of sizes, from flagships to compact ones, so there is something to match any hardware.

For an assistant that keeps context directly on the device, Muse Glimmer 30B fits: 29.6 billion, under 20 GB compressed, with a 131 000-word context window.

The ready GPT assistants and the prompt library are useful alongside.

For modest hardware

You take not a flagship but a compact dense model — one without the split into parts.

There are several convenient options right now: Muse Glimmer 30B (under 20 GB compressed) and Qwen 3.8 27B, which handles images and has a separate memory-saving build.

Memory guide:

Exact requirements depend on the degree of compression and the context length — check the card of the specific build.

---

Part 4. The families in detail

Qwen 3.8 (Alibaba)

Alibaba's current generation of open models, succeeding Qwen3.

The flagship Qwen 3.8 Max is 2.4 trillion in total with 95 billion active. In the first release the weights are open and the model is text-only, with no image handling. The full version weighs around 5 TB — not something to run at home, but the fact itself matters: the top tier of quality moved into open weights entirely, not as a cut-down version.

Alibaba then published Qwen 3.8 27B — a dense model that handles images, with a separate lightweight build. This is the one people were waiting for to run locally.

The size range is still being filled out: the team said publicly it is "working on more sizes and architectures". The community expects a 122 billion variant, but it is not officially confirmed.

Be careful with the licence. The earlier Qwen3 shipped under the free Apache 2.0, while the text of the Qwen 3.8 Max licence in its first release raised questions over regional clauses. Before deploying commercially, read the current version on the card rather than relying on "it used to be Apache."

DeepSeek V4

DeepSeek's current generation. Two notable open-weight releases.

DeepSeek V4-Flash 0731 — 284 billion with 13 billion active, 256 expert parts (6 switch on per word), built-in generation acceleration. A million-word context, MIT licence. API prices started at $0.14 per million input and $0.28 per million output words, with a 98% discount on repeated text.

DeepSeek V4 Pro came out of preview with MIT weights (card): around 1.7 trillion, with its DeepSWE result jumping from 12.8 to 62.7.

At the same time DeepSeek open-sourced its agent harness under MIT — a signal that an environment for long autonomous tasks is being built around the model as well.

The practical point of splitting into parts is running cost: with a huge reserve of knowledge, only a few per cent of the model is actually computed per word. That makes flagship-quality work more affordable in hardware terms than an equally strong dense model would be.

Kimi K3 (Moonshot AI)

Moonshot AI's current flagship and, at release, the largest open model in history: 2.8 trillion with ~104 billion active.

An enormous total against a modest active share is this family's signature: reserve for complex multi-step tasks without a proportional rise in the cost of each step.

By independent reliability measurements, Kimi K3 is the strongest of the open models.

The ecosystem picked the release up instantly: enthusiasts squeezed the model from 1.56 TB down to 594 GB while keeping around 79% accuracy and ran it on home workstations, while server builds reached hundreds of words per second.

Read the licence on the card: the previous Kimi K2 came under a Modified MIT with an attribution clause for very large products.

GLM-5.3 (Z.ai)

The development of the GLM-5.2 and GLM-4.6 line.

What is unusual is that the improvements came not from changing the base model but from further training on long agent tasks: Terminal-Bench 3.0 rose from 4.6 to 28.3, DeepSWE v1.1 from 46.2 to 66.9.

The release's biggest surprise was unexpectedly strong cybersecurity: 84.5% on the CyberGym benchmark and 2 436 vulnerabilities found across 269 open projects, 1 097 of them critical or high.

An important caveat on availability: as this guide goes out, the open weights are GLM-5.2 under MIT, with 5.3 weights promised roughly two weeks after safety review. If you need an open model right now, work from 5.2.

The MIT licence makes GLM attractive where legal cleanliness is critical: no user thresholds and no mandatory attribution.

Meta (Muse Glimmer)

Meta's open model for the current generation, replacing the Llama line. And it is not only a change of name.

Llama was distributed under a community licence with caveats: a "Built with Llama" attribution and a threshold of 700 million active users. Muse Glimmer 30B shipped under the free Apache 2.0 — a significant turn for teams that need a legally clean base.

It is a dense 29.6 billion model, under 20 GB compressed, with a 131 000-word context, tuned for local always-on scenarios.

By NVIDIA's write-up its strength is steady agent work on ordinary hardware rather than records on summary tables.

---

Part 5. How to shrink a model to fit your hardware

Compression means reducing the precision of the numbers the model is written in: from 16 bits down to 4 bits per parameter, for instance. In practice that cuts the memory footprint several times over with almost no loss of quality.

Compression is exactly what makes local running possible on budget hardware.

The common format is 4 bits: the best balance of size and quality for home use.

The rule of thumb is simple: at 4 bits, every billion parameters takes roughly 0.5–0.6 GB. So 7–8 billion fits in 8 GB, and 27–30 billion needs 16–20 GB.

Compression helps with giant models too: Kimi K3 was squeezed from 1.56 TB to 594 GB, Qwen 3.8 from 4.9 TB to 397 GB. That moves a server model into the range of a powerful home workstation.

But the total size of the flagships still demands a lot of memory, so compact dense models are more practical at home than flagships split into parts.

---

Part 6. Why rankings cannot be trusted blindly

A benchmark is a standard test used to compare models on a shared task: code, reasoning, knowledge.

Relying on the top rows alone is risky for three reasons.

Headlines age fast. Open models update almost weekly: August 2026 alone saw several flagships change hands.

A benchmark measures its own task, not yours. A high score on an engineering test does not guarantee the model writes your code on your stack well.

Some rankings mix open and closed models — it is easy to mistake something you cannot download for "open".

And a trap of its own: the harness matters more than the model. In several measurements, changing the wrapper program around a model moved the result more than upgrading the model did.

The sensible approach: narrow the list by licence and size, then run two or three models on your own real tasks. Fresh measurements for specific scenarios are collected in the daily digests.

---

Part 7. How to run one locally

The easiest route is a ready launcher — Ollama, LM Studio or llama.cpp. They hide the fiddling with compression and model files.

The general route: pick a model sized for your hardware → download the compressed version → run it → query it locally.

For a compact model such as Muse Glimmer 30B or Qwen 3.8 27B, budget 16–20 GB of video memory at 4-bit compression. Flagships need a server or a powerful workstation.

The accompanying tools and launchers are collected in the Open Source section.

Where this is taught step by step

The general route above answers "what to do". "How exactly" is answered by a separate module of the programme — "Working with AI software".

It covers local generative models concretely: deployment, picking a build for your hardware, compression, running them, and the things people normally learn by trial and error — where the model will hit a memory wall, which settings genuinely affect speed, what breaks on an update.

This is not an express course but part of the main programme, the Full plan. Access to the local models themselves is included there too.

Why Full rather than a lower plan. Local deployment is not an entry-level activity: it needs hardware, a willingness to maintain it, and an understanding of why you want it instead of a ready solution. If you are unsure, run the test at the end of this article first.

---

Part 8. Where the money is

The section usually missing from reviews like this: they end at "pick a model".

The argument that frightens a client more than the price

When you sell a company an always-on system, the client asks two questions. What does implementation cost — and what will it cost every month.

The second frightens them more. They are ready to spend money once; signing up to an open-ended payment whose size depends on load, they are not.

The sentence "part of the load runs on a model deployed on your side and is not metered" removes that objection entirely.

The argument that outweighs money

Data.

For a clinic, a law firm or a financial company, local deployment is a condition of the deal, not an advantage. Without it the conversation does not start.

If you work with clients like that, this is your ticket in — and simultaneously what rules out competitors with ordinary solutions.

How to word it in a proposal

Not "we use open models" — that tells the client nothing.

But this: "sensitive data is processed on your server and never leaves your perimeter; complex tasks go out to external models, and that is a separate small cost line you can see in the dashboard."

Transparent, verifiable, and it removes both fears at once.

The hybrid setup

Almost nobody works purely locally, and rightly so.

Kept local: everything sensitive, accumulated context, regular repetitive tasks, work with internal documents.

Sent out: complex creative tasks, image and video generation, searching for fresh information, anything where the top models are clearly better.

The rule: if there is data that cannot leave, keep it local regardless of quality. If there is no such data and you need the best result, send it out.

And one format worth knowing separately. Ordinary assistants live in a browser tab: close it and they forget you, and every request is billed. There is another kind — a background service on your own hardware that runs continuously, remembers you between sessions and does not invoice per request.

Plus two properties a tab cannot have in principle: it starts the conversation itself when an event occurs, and it lives in messengers rather than in a separate window.

The express course "OpenClaw: not a browser helper but your own AI operator" is about deploying such a service. What you end up with: a working operator on your hardware connected to WhatsApp, Telegram, Discord, iMessage and Slack, a library of 50+ capabilities, and a configured memory system.

For somebody who has already stood up a local model this is the logical next step: the model answers, and the operator turns it into a permanently working assistant.

$9, included in the Make and Team plans.

The price range

From a scrape of 848 job listings over 24 days: a system or pipeline runs $490–1 460, against a median one-off job of $30–75.

An honest caveat: an explicit budget appears in 6% of listings, with two to fifteen observations per category.

A real example: a system for a dental clinic at $1 900 a year, paid in full. The comparison was not against zero but against an in-house team at roughly $720 a month plus taxes and holidays.

The segment is narrow but the fee is higher and the clients are long-term: a system built into an organisation's perimeter does not get replaced every year. You look for these clients not in a general job feed but through the industry — wherever data requirements exist by definition.

---

Part 9. What to open up for your task

Before deploying your own, check whether the task has a simpler answer.

Ready-made assistants. More than 140 across 14 categories. If the task sounds like "I need a helper for this subject", the answer is probably here. Plan: Basic.

Automation templates. More than 3 000 flows. If the task is mechanical, a local model is overkill for it. Plan: Plus.

An encyclopedia of more than 190 vetted services — so you know what does what before choosing a tool. Included in Basic.

Open Source. Ready projects you deploy yourself: runners, vector databases, agent harnesses, tools. The catalogue is open to everyone, file links after free registration.

The ladder for those going their own way

Four steps, from cheap to serious.

1. The "AI Agents" express course. The wiring around a model: 20 finished projects, four platforms, n8n among them — the only one you can stand up beside a local model on your own server. $9, the Make and Team plans.

2. The "OpenClaw" express course. A background operator on your own hardware: local memory, proactivity, messengers, 50+ capabilities. $9, the Make and Team plans.

3. The programme module "Working with AI software". Local generative models step by step: deployment, choosing a build for your hardware, compression, running. Plus access to the local models themselves. The Full plan.

4. The "Enterprise automation: Make and n8n" module. The top level: private environments and the archives of ready Make and n8n wirings. The Full plan.

Neither express course is included in the three free days of Basic — a one-off purchase, the relevant plan, or 1 000 XP points.

The order matters. The first two steps cost $9 each and answer the question "do I need this at all". Full is taken by people whom the first two convinced that they do.

---

Checklist: what to settle before downloading

Five questions better asked before than after.

---

Release timeline

Open models update almost weekly, which is why monthly rankings go stale.

August 2026 alone brought open weights for Qwen 3.8 Max and Qwen 3.8 27B, DeepSeek V4 Pro, Meta opening Muse Glimmer 30B, and Z.ai showing GLM-5.3.

We track releases in the daily AI digests — fresh figures, licences and practical community measurements appear there earlier than in monthly round-ups.

---

FAQ

Can open models be used commercially?

It depends on the licence, and this is the main question before deployment.

Muse Glimmer 30B (Apache 2.0), DeepSeek V4 (MIT) and GLM-5.2 (MIT) permit commercial use with almost no conditions. The Qwen 3.8 and Kimi K3 licences need reading on the card: Qwen 3.8 Max raised questions over regional clauses, and the previous Kimi K2 carried a Modified MIT requiring attribution for very large products.

Before production, always check the current licence text for the specific model.

What do the two numbers in a model's size mean?

Some modern models are split into many expert parts, and only a small share switches on per word.

The total shows what the model weighs and how much memory it needs; the active figure shows how much is actually computed, which drives speed and cost. A large total gives a reserve of knowledge, a small active part gives acceptable speed.

But the memory has to cover the total, not the active part — that is the main thing to remember when choosing for your hardware.

Have open models caught up with closed ones?

On a number of tasks the gap has narrowed markedly: open flagships post competitive results on engineering and agent tests. And what matters most is that you can run them yourself and not depend on somebody else's service.

Comparisons still need care: headlines age fast and tests do not always reflect your task. It is more practical to check a model on your own data.

How do open weights differ from local running?

Two different things that often get confused.

Open weights is a property of the model: its parameters are published and can be downloaded.

Local running is a way of using it: you run the model on your own hardware.

An open model can be run locally, in the cloud, or through somebody else's hosting. And only models whose weights are open can be run locally.

Should I be doing this at all?

A simple test. Write down the tasks you do not give to AI because the data is sensitive. Not the ones you solve — the ones you do not attempt at all.

An empty list means local models are not your topic yet, and that is a perfectly good answer. Ordinary tools will cover the same ground more cheaply.

Three or four regular tasks on the list is your justification. And that same list is what you show a manager or a client: it convinces better than any account of the technology.

---

Try it

Registration is free and opens three days of full Basic access — Open Source, all 140+ assistants, the encyclopedia of more than 190 vetted services, the prompt texts, the skill files and six foundational courses.

Three days is enough to check the main thing: whether a ready solution already covers your task, before you spend a weekend configuring hardware.

What to read next

Local AI models for sensitive data — what stays inside the perimeter and how to sell it.

A local AI operator with memory — a background service instead of a browser tab.

A company knowledge base as a service — RAG on private documents.

How to choose an AI tool for a task — five criteria in the order you apply them.

What it costs to try — pay-per-use instead of subscriptions.

Automation without a developer — what gets built around a deployed model.

AI for engineers — where calculations cannot be trusted.

AI in medicine — an industry where locality is a condition of working.

Bringing AI into your team — if your company has data requirements.

n8n and Make automation templates — what gets built around a model.