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

2026-08-16

Open weights means a company publishes the model itself: it can be downloaded and run on your own hardware, without going through anyone else's service.

Open weights means a company publishes the model itself: it can be downloaded and run on your own hardware, without going through anyone else's service.

Why that matters in practice: the data does not leave your building, nobody charges per request, and the model cannot be withdrawn — you already have it.

Below: how open weights differ from open source, a comparison of five flagships by size and licence, what to choose for code, for text and for weak hardware, how to shrink a model to fit your equipment, where the money is and how to run one locally.

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

The short version

"Open weights" and "open source" are different things. The model can be downloaded, but its training usually cannot be reproduced from scratch.

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

The licence matters more than the ranking. The freest at present are Hy4 preview and Muse Glimmer (Apache 2.0), DeepSeek V4 and GLM-5.3-Flash (MIT). The Kimi K3 and GLM-5.3 flagships have their own licences, and those files need reading.

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

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

There is money here. A local model is the entry ticket to clients who cannot let data leave the building. Such projects run $490–1 460, from a scrape of 5 986 jobs over four months.

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 come out under genuinely free licences — Apache 2.0, MIT. They can be used commercially with almost no conditions.

Others arrive under "community" licences with caveats: attribution requirements, a threshold on user numbers, 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 its open Muse Glimmer 30B under Apache 2.0 for the first time, and DeepSeek publishes V4 under MIT. The most notable releases of 2026 are not only stronger but legally cleaner.

Why this instead of a convenient API

Three reasons.

Privacy and control. The data does not go 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 large volumes running your own often costs less than paying per call, and the price is predictable — particularly given that even inexpensive APIs are rising: DeepSeek raised its rates from 16 August 2026.

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

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

Part 2. Comparing the flagships

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

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 — remain usable but fall short of 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 "specialist" 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 — 284 billion in total but only 13 billion active. Qwen 3.8 Max — 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 size.

The second thing people look at after size

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

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

The current generation has 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 choose for the task rather than taking the maximum in reserve.

Part 3. What to choose for the task

The choice comes down to three things: the task, your hardware and an acceptable licence.

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 under MIT — which removes most of the legal questions for a product.

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

Alongside the model you normally need tools and a harness — ready processes are conveniently taken from the automation templates section, and the knowledge of "how to lead an agent through steps" from the Skills for Claude Code hub.

And separately, about what most people are missing. A deployed model on its own does nothing — it answers requests. For it to work inside a process you need a chain: what starts it, where the result goes, what happens on failure.

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

The express course “AI agents: the electrification of routine” covers exactly this: from your first automatic agent to chains running around the clock. Inside are 20 ready ideas with a starting structure and four platforms — Make, n8n, Relevance and Lindy.

n8n is particularly apt here: it is the only one of the four you can bring 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, N8N and Full plans. Not part of the three free Basic days.

For text in multiple languages

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

Both come in a range of sizes — from flagships to compact — so a version can be matched to any hardware.

For an assistant holding context on the device itself, Muse Glimmer 30B suits: 29.6 billion, under 20 GB compressed, a context window of 131 thousand words.

Ready GPT assistants and the prompt library are useful alongside.

For weak hardware

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

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

Memory guidance:

• A 27–30 billion model compressed — around 16–20 GB of video memory
• A 7–8 billion model — fits in 8 GB
• For genuinely weak devices there is a separate class: LFM2.5 at 2.69 billion runs on a phone at around 30 words per second on ~2.4 GB of memory

Exact requirements depend on the degree of compression and the context length — check the card for 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 — 2.4 trillion in total with 95 billion active. In the first publication the weights are open and the model is text-only for now, 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 has moved into open weights in full rather than as a cut-down version.

Alibaba then released 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 line-up is still being filled out: the team has said publicly that it is "working on more sizes and architectures". The community is expecting a 122 billion variant, but it is not officially confirmed.

Be careful with the licence. The earlier Qwen3 came out under the free Apache 2.0, while the text of the Qwen 3.8 Max licence in its first publication raised questions over regional clauses. Before commercial deployment, read the current revision on the card rather than relying on "it used to be Apache".

DeepSeek V4

DeepSeek's current generation. Two notable releases with open weights.

DeepSeek V4-Flash 0731 — 284 billion with 13 billion active, 256 specialist parts (6 switch on per word), built-in generation acceleration. Context of a million words, MIT licence. API prices started from $0.14 per million input and $0.28 per million output tokens.

With a 98% discount on repeated text.

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

At the same time DeepSeek opened its own 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 an enormous reserve of knowledge, only single-digit percentages of the model are actually computed per word. That makes flagship-quality work more affordable in hardware terms than an equally strong dense model.

Kimi K3 (Moonshot AI)

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

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

On independent reliability measurements Kimi K3 is the strongest among open models.

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

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

GLM-5.3 (Z.ai)

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

What stands out 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 main surprise was unexpectedly strong cybersecurity: 84.5% on the CyberGym benchmark and 2 436 vulnerabilities found across 269 open projects, of which 1 097 were critical or high severity.

What matters about the licence. The 5.3 weights came out on 28 August 2026, but not under MIT like the previous versions — under Z.ai's own document: MIT-like permissions with one caveat, that operators of services with revenue above ten billion dollars a year must pass a vendor security review.

In practice that concerns none of this article's readers, but the licence file still needs reading: earlier versions of the line ran under clean MIT, and out of habit people attribute it to this one too.

The junior GLM-5.3-Flash came out two days earlier under ordinary MIT — 320 billion total, 18 active. If legal cleanliness matters more than maximum quality, that is where to start.

Tencent (Hy4 preview)

A family absent from reviews like this a year ago and impossible to leave out now.

Hy4 preview arrived on 28 August 2026: 770 billion total, 49 active, a context of a million words. The weights were opened the same day.

The main thing here is not the size but the licence — Apache 2.0 with no caveats. As of today this is the largest model released under a genuinely free licence: Kimi K3 is bigger but comes under its own, and GLM-5.3 likewise.

The pace deserves a separate mention. The previous generation arrived on 6 July at 295 billion with a 256 thousand context. Fifty-three days later came a model two and a half times larger with four times the context.

An honest caveat: almost all published figures are the vendor's own measurements, and independent ones are still scarce. And you cannot run it yourself: the official recipe calls for 16 B200 accelerators, which means a data centre rather than a workstation.

Meta (Muse Glimmer)

Meta's current-generation open model, succeeding 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 came out under the free Apache 2.0 — an important turn for teams needing a legally clean base.

It is a dense model of 29.6 billion, under 20 GB compressed, with a context of 131 thousand words, tuned for local continuously running scenarios.

By NVIDIA's write-up its strength is steady operation as an agent on ordinary hardware, rather than records in summary tables.

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

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

Compression is precisely what makes local running possible on budget equipment.

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

The guidance is simple: at 4 bits each billion parameters takes roughly 0.5–0.6 GB. Hence 7–8 billion fits in 8 GB, and 27–30 billion needs 16–20 GB.

Compression helps with the giant models too: Kimi K3 has been squeezed to 594 GB from 1.56 TB, and Qwen 3.8 from 4.9 TB to 397 GB. That moves a server model into the class of things runnable on a powerful home workstation.

But the total size of the flagships still demands a great deal of memory, so for home use compact dense models are more practical 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 date fast. Open models update almost weekly: several flagships changed during August 2026 alone.

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 take something undownloadable for "open".

And a separate trap: the harness matters more than the model. In a number of measurements, changing the software wrapper around a model moved the result more than upgrading the model itself.

The practical 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 simplest route is through ready launcher programs — Ollama, LM Studio or llama.cpp. They hide the fiddling with compression and model files.

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

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

Related tools and launchers are collected in the Open Source section. Found there on this topic: llama.cpp — local LLM inference without a GPU, Jan — an offline AI chat on your own computer, A web interface for running LLMs locally, Unsloth — fine-tuning LLMs on your own hardware, DeepSeek — open LLMs for reasoning and code, Qwen3 — open multilingual LLMs from Alibaba. Descriptions are open to everyone, repository links come with Creator.

Where this is taught step by step

The general route above answers "what to do". The question of "how exactly" is answered by a separate course — “Working with AI software”.

That is 36 lessons — not an overview but a sequential walkthrough of local generative models for images and video: Stable Diffusion (local installation on a PC and in Google Colab, Control Net, Inpaint, Upscale, Forge), ComfyUI, Deforum, and training your own LoRA models. There are no lessons on local language models (running Qwen, DeepSeek and others through Ollama or LM Studio) — for those, see the Open Source section.

This is not an express course but part of the main programme, the Full plan.

Why Full rather than a junior plan. Local deployment is not an entry level: it requires hardware, a willingness to maintain it, and an understanding of why you want it instead of a ready solution. If in doubt, work through the check at the end of this article first.

Part 8. Where the money is in this

The section such overviews usually lack: they end at "choose a model".

The argument that frightens a client more than the price

When you sell a company a system that runs continuously, the client asks two questions. What does implementation cost — and what will this cost every month.

The second frightens more. He is prepared to spend one-off money; signing up to an open-ended payment whose size depends on load, he is not.

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

The argument that weighs more than 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 these, that is your entry ticket — and at the same time what cuts out competitors offering ordinary solutions.

How to phrase it in a proposal

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

Instead: "sensitive data is processed on your server and does not leave your perimeter; complex tasks go 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 arrangement

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 quality of the top models is noticeably higher.

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 call is metered. There is another kind — a background service on your own hardware that runs continuously, remembers you between sessions and does not bill per request.

Plus two properties a tab cannot have at all: it initiates contact itself when an event fires, and it lives in messengers rather than in a separate window.

The express course “OpenClaw: not a browser assistant but your own AI operator” covers 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+ skills and a configured memory system.

For someone who has already brought up a local model this is the logical continuation: the model answers, and the operator turns it into a permanently working assistant.

$9, included in the Make, N8N and Full plans.

The order of prices

From a scrape of 5 986 jobs over four months: a system or a pipeline runs $490–1 460, against a median one-off job of around $60.

An honest caveat: an explicit budget appears in 17% of listings, and by individual type of work there are between twenty and three hundred observations with a figure.

A real example: a system for Zakhar Fomin's dental clinic (the contractor was Denis, the founder) 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 cheque is higher and the clients are long-term: a system built into an organisation's perimeter does not get replaced annually. Clients like these are found not in a general job feed but through the industry — where data requirements exist by definition.

Part 9. What to open for your own task

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

Ready assistants. 200+. If the task sounds like "I need an assistant for this subject", the answer is most likely here. Basic plan.

Automation templates. Over 3 000 scenarios. If the task is mechanical, a local model is overkill for it. Creator plan.

An encyclopaedia of 198 vetted services — to see what is done with what before choosing a tool. Included in Basic.

Open Source. Ready projects you deploy yourself: runners, vector databases, agent harnesses, tools. Descriptions are open to everyone, repository links from the Creator plan.

The ladder for those going their own way

Four steps, from cheap to serious.

1. The "AI agents" express course. The chains around a model: 20 ready ideas, four platforms, among them n8n — the only one you can bring up next to a local model on your own server. $9, the Make, N8N and Full plans.

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

3. The course “Working with AI software”. Local generative models for images and video step by step: Stable Diffusion, ComfyUI, Deforum, your own LoRAs. Full plan.

4. The courses “Automations in n8n” and “Automations in Make”. Building processes around a model: each is included in its own plan (N8N and Make) and in Full.

Neither express course is part of the three free Basic days — a one-off purchase, the corresponding plan, or 1 000 experience 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 consider before downloading

Five questions better asked before than after.

• The licence for your scenario. For a commercial product, Apache 2.0 (Muse Glimmer) or MIT (DeepSeek V4, GLM-5.2) is safer. Read the Qwen 3.8 and Kimi K3 licences on the card.
• The task. Code and agents — the large DeepSeek V4 Pro, Qwen 3.8 Max, GLM-5.3, Kimi K3. Multilingual text — Qwen 3.8 and DeepSeek V4. Weak hardware — the compact Muse Glimmer 30B and Qwen 3.8 27B.
• Memory. Work out the budget with compression in mind: 0.5–0.6 GB per billion parameters at 4 bits. That rules out half the options straight away.
• Freshness. Check whether a new version has come out: some weights, as with GLM-5.3, open with a delay after the announcement.
• A test on your own data. The final decision comes from running two or three candidates on a real task, not from a row in a ranking.

Release chronicle

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

How fast is visible from a single month. During August 2026 the open weights of Qwen 3.8 Max and Qwen 3.8 27B and of DeepSeek V4 Pro were released, and Meta opened Muse Glimmer 30B. On 14 August Z.ai shipped GLM-5.3, on the 26th GLM-5.3-Flash under MIT, and on the 28th the flagship weights under its own licence. On the same day, 28 August, Tencent opened Hy4 preview under Apache 2.0.

Four flagship releases in two weeks, and half of them changed the picture on licences rather than on benchmarks.

Hence the practical conclusion: every table in this article is a snapshot, not a constant. Before choosing a model for a project, check the card: the figures may not have changed, but the licence may have.

Following this is easier in the AI digest — a daily feed of industry news where releases, licences and measurements appear on the day rather than in monthly round-ups.

FAQ

Can open models be used commercially?

It depends on the licence, and that 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 used a Modified MIT requiring attribution for very large products.

Before production, always check against 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 "specialist" parts, and only a small share of them switches on per word.

The total number shows what the model weighs and how much memory it needs; the active one shows how much is actually computed, which determines 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 size, not the active one — that is the main thing to remember when choosing for your hardware.

Have open models caught up with closed ones?

On a range of tasks the gap has narrowed considerably: open flagships show competitive results on engineering and agent tests. And what matters most is that they can be run on your own hardware without depending on anyone else's service.

Comparisons should still be made carefully: headlines date 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?

These are different things, often 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 someone else's hosting. And locally you can only run those whose weights are open.

Should I be doing this at all?

A simple check. Write down the tasks you do not give to models because of data sensitivity. Not the ones you solve, but the ones you do not solve at all.

An empty list means the subject of local models is not for you 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. Three days of the Basic plan switch on with one button, no card needed: Basic includes 200+ AI assistants, prompt texts, skill files, five programme courses (including “Sales”) and six Basic mini-courses — among them “Freelancer positioning”, Freelance 2.0, Perplexity, Grok and the encyclopaedia of 198 vetted services.

Three days is enough to check the main thing: whether your task is solved by a ready solution — before you spend a weekend configuring hardware.

What to read next

Local models for sensitive data — what is kept 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 a model for a task — five criteria in the order they apply.

What it costs to try — paying for what you 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 department — if your company has data requirements.

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