You keep hearing that open source LLMs have caught up. Your Claude or ChatGPT bill keeps climbing, a client asks whether their data can stay in-house, and every list you open ranks fifteen models by benchmark without telling you the one thing you need to know: is any of them good enough for your actual work, and is switching worth the hassle?
I asked the same question twice, two years apart, and got two different answers. In 2024 I evaluated open models for clients in regulated industries and walked away. In 2026 one of them cleared my bar for real work, I paid for it, and then I cancelled it anyway. Below are the open models worth knowing in November 2026, with their real licences, a ranked top 3, the self-hosting maths I did, a copyable setup for running a cheap open model inside Claude Code, and a one-week test you can run before you switch anything.
On this page
The short answer
An open source LLM is a language model whose weights you can download, run on your own hardware and, depending on the licence, fine-tune and use commercially. In 2026 the best of them are genuinely good: GLM 5.2 was the first open model I rated between Claude 4.6 and 4.8, after putting about 50 million tokens through it in 24 hours. But for most solo builders and small teams already on a frontier subscription, the honest answer is to use open models for specific jobs, not to switch wholesale.
The open model that cleared my bar is not one you can run on your desk. GLM 5.2 has 753 billion parameters. The open models that fit on a single workstation are a different, smaller class, and you should judge them separately.
My ranked top 3 for a solo builder right now:
- GLM-5.2 (Z.ai, MIT licence) for real coding and agent work. The only open model I have rated close to frontier quality.
- DeepSeek V4.1-Flash (DeepSeek, MIT licence) for long, simple, high-volume tasks you do not want burning your premium limits. The DeepSeek API is the one open-model service I kept.
- Qwen3.8-27B (Alibaba, Apache 2.0) if you must self-host on one machine. This is a research pick, not a lived one: I have not run it.
Open source or open weights: what you actually get
Most “open source” LLMs are open weights. You get the trained model file and a licence. You usually do not get the training data or the full training code, which is what the Open Source Initiative’s definition of open source AI asks for. For a builder, the distinction that matters is the licence, because it decides whether you can ship a product on the model.
| Licence type | Models (Nov 2026) | What it means for you |
|---|---|---|
| MIT | GLM-5.2, GLM-5.3-Flash, DeepSeek V4 and V4.1 | Use, modify and sell with almost no conditions |
| Apache 2.0 | Qwen3.5, Qwen3.8-27B, Gemma 4, gpt-oss-120b | Same freedom, plus an explicit patent grant |
| Custom licence | GLM-5.3, Kimi K3, MiniMax M3, Llama 4 | Commercial use allowed, but with attribution rules or conditions above a size or revenue threshold. Read the file before you build on it |
Check the licence on the model’s own Hugging Face page, not a blog summary. For example, the Kimi K3 licence and the MiniMax M3 licence both add conditions that an MIT model does not have, and GLM-5.3 moved to a custom licence where GLM-5.2 was MIT. The DeepSeek V4-Flash model card, by contrast, is plain MIT.
If you want the trade-offs framed for a business before going further, this explainer from Box’s AI series is a sober 17 minutes on open versus closed models. It predates the 2026 releases, but the decision framework still holds:
The open models worth knowing in November 2026
Sizes, context windows and licences below come from each model’s Hugging Face page, checked on 9 November 2026. “Total” is the full parameter count; mixture-of-experts models only activate part of it per token, but you still need memory for all of it to self-host.
| Model | Maker | Total size | Context | Licence | My verdict |
|---|---|---|---|---|---|
| GLM-5.2 | Z.ai | 753B | 1M | MIT | Used it. First open model I rated between Claude 4.6 and 4.8 |
| DeepSeek V4.1-Flash | DeepSeek | 763B | 1M | MIT | Use the API for trivial but long tasks |
| Kimi K3 | Moonshot AI | 2.8T | 1M | Custom | Not tested. The K3.1 Pro variant leads the open leaderboard |
| Qwen3.8-27B | Alibaba | 27B | 262K | Apache 2.0 | Not tested. The realistic single-GPU self-host pick |
| Gemma 4 31B | 31B | 262K | Apache 2.0 | Not tested. Small enough for one workstation | |
| MiniMax M3 | MiniMax | 427B | 1M | Custom | Not tested |
| Llama 4 Maverick | Meta | 402B | 1M | Custom | Not tested. Released April 2025 |
| gpt-oss-120b | OpenAI | 117B | 131K | Apache 2.0 | Not tested. August 2025 |
For a live ranking, Artificial Analysis’s open-weights leaderboard is the one I would bookmark. As I write, Kimi K3.1 Pro leads its intelligence index with a score of about 46, well clear of the next group in the low 30s. Treat that as a shortlist, not a verdict. A leaderboard tells you which model is strongest on average; only your own tasks tell you whether it is strong enough for you.
Why GLM-5.2 is my number one even though Kimi tops the board: it is the only one I have pushed through real work at volume, and its MIT licence is the cleanest on the list. If you are choosing a model to fine-tune or self-host for a product, GLM-5.2’s weights are a safer legal bet than its successor’s.
Which open model for which job
| Your job | Pick | Why |
|---|---|---|
| Coding agents and real feature work | GLM-5.2 | The only open model I rated near frontier quality, and MIT licensed |
| Long, simple, high-volume tasks | DeepSeek V4.1-Flash via the API | Cheap per token, and the one open-model service I kept |
| Self-hosting on one GPU | Qwen3.8-27B or Gemma 4 31B | 27B to 31B parameters, Apache 2.0 (research pick) |
| A laptop, phone or edge device | Gemma 4 E4B | About 8B parameters in total, Apache 2.0 (research pick) |
| Fine-tuning your own model | Qwen3.8-27B or GLM-5.2 | Permissive licences; pick by the hardware you have |
| The strongest open model, licence permitting | Kimi K3.1 Pro | Top of the open leaderboard, custom licence (not tested) |
What hardware you need to run an open source LLM
You can estimate the memory a model needs from its parameter count. The weights alone take parameters (in billions) times bits per weight, divided by 8, in gigabytes. Then add about 20 percent for the context cache and runtime. Copy this:
Memory needed (GB) = parameters (billions) x bits per weight / 8 x 1.2
Qwen3.8-27B at 4-bit: 27 x 4 / 8 x 1.2 = about 16 GB
Qwen3.8-27B at 8-bit: 27 x 8 / 8 x 1.2 = about 32 GB
GLM-5.2 at 4-bit: 753 x 4 / 8 x 1.2 = about 450 GB
Those figures are estimates from the parameter counts on each model card, not measurements of mine. A 4-bit quantized model is smaller and a little less accurate than the full one. Long contexts need more cache than the 20 percent allowance.
| Memory you have | What fits (4-bit unless noted) |
|---|---|
| 8 GB | Gemma 4 E2B or E4B |
| 16 to 24 GB | Qwen3.8-27B or Gemma 4 31B, tight at 16 GB and comfortable at 24 GB |
| 32 to 64 GB | The same 27B to 31B models at 8-bit, with room for longer context |
| 80 to 128 GB | gpt-oss-120b, which OpenAI’s card says fits on a single 80 GB GPU |
| Hundreds of GB, multi-GPU | MiniMax M3, Llama 4 Maverick, GLM-5.2, DeepSeek V4.1-Flash |
| Over a terabyte | Kimi K3 |
How to run an open source LLM locally
The usual tools are Ollama and LM Studio for a single machine. llama.cpp is the engine many of them build on. vLLM is the common choice for serving a model to a team on GPUs. I have not run any of them myself, so treat this as a map rather than a recommendation. The model choice and the test below matter more than the runner.
What changed my mind between 2024 and 2026
In 2024 I wanted to build on open models for EU and regulated-industry clients, where keeping data inside your own walls is the whole pitch. I evaluated them seriously and abandoned the idea. Quality was too poor and, worse, too unpredictable, and an unpredictable model is hard to put in front of a compliance team. I moved to frontier models instead.
I also costed self-hosting at the time. For a team of two to ten people it came to a Mac Studio at $5,000 to $10,000 plus $200 to $800 a month in running costs. For heavier use, amortised over four years, it came to roughly $4,000 to $5,000 a month.
In 2024 the open models were cheap to run and expensive to trust.
What changed was GLM 5.2. I burned about 50 million tokens through it in 24 hours and rated its quality between Claude 4.6 and 4.8. That was the first time an open model cleared my bar. It was also genuinely better than I expected on front-end work, which is usually where non-frontier models fall apart first. I wrote up the paid plan in detail in my GLM Coding Plan review, including the config to run it inside Claude Code.
Good enough is not the same as worth switching
Here is the part the ranking lists leave out. I paid for GLM through Z.ai’s coding plan, liked it, and cancelled it.
The model was good. Its only real advantage over what I already use was price. My total personal AI spend is about $500 to $600 a month across providers, and switching would have saved me $100 to $200 of that in exchange for doing my work on a model I knew was not the best available. For anyone whose time is the expensive input, that trade loses.
The subscription maths makes this sharper. I run 15 to 20 billion tokens a month through these tools. At API list prices that would be $15,000 to $20,000 a month; on subscriptions I pay $500 to $600. An open model has to beat a flat-rate subscription, not an API bill, and while the labs keep subsidising heavy users, that is a hard comparison to win.
Use this worksheet before you decide. Fill in your own numbers; mine from 2024 are in the right-hand column.
| Line | Your number | My 2024 estimate |
|---|---|---|
| Hardware, divided by months you will keep it | $5,000 to $10,000 Mac Studio | |
| Power, hosting and spares per month | $200 to $800 | |
| Your hours per month keeping it running, times your hourly rate | Not counted then. Count it now | |
| Hosted open model API instead: tokens per month times the provider’s price | Check Z.ai or DeepSeek pricing | |
| What you pay today | About $500 to $600 a month in 2026 |
One warning about that first row. The hardware I priced in 2024 will not hold the models that matter now. The open models that cleared my bar in 2026 run from 753 billion to 2.8 trillion parameters, which is multi-GPU server territory, not a desk. If self-hosting is the requirement, your real candidates are the 27B to 31B models, so test those against your work rather than assuming GLM-level quality.
Three jobs where an open model earns its place
I did not walk away from open models. I narrowed them to jobs where they win.
1. Long, simple tasks that would burn your premium limits
I kept the DeepSeek API, and I use it rarely and deliberately: for tasks that are trivial but long, so my Claude weekly limits are not spent on them. Typical examples: reformatting a big file, summarising a long log, or bulk renaming. You do not need your best model to do boring work.
DeepSeek publishes an Anthropic-compatible endpoint and official Claude Code setup instructions. If you want the same split without touching your normal setup, wrap them in a shell function. This is built from DeepSeek’s documented variables; plain claude keeps using your usual plan:
# Add to ~/.zshrc or ~/.bashrc, then: export DEEPSEEK_API_KEY=... (or load it from your secrets manager)
# Usage: claude-ds "summarise build.log and list every distinct error"
claude-ds() {
ANTHROPIC_BASE_URL="https://api.deepseek.com/anthropic" \
ANTHROPIC_AUTH_TOKEN="$DEEPSEEK_API_KEY" \
ANTHROPIC_MODEL="deepseek-flash[1m]" \
ANTHROPIC_DEFAULT_OPUS_MODEL="deepseek-flash[1m]" \
ANTHROPIC_DEFAULT_SONNET_MODEL="deepseek-flash[1m]" \
ANTHROPIC_DEFAULT_HAIKU_MODEL="deepseek-flash" \
CLAUDE_CODE_SUBAGENT_MODEL="deepseek-flash" \
claude "$@"
}
Because the variables are set only for that one command, nothing leaks into your other sessions. DeepSeek is based in China and processes your prompts there, so keep client code and personal data out of it unless your contracts allow that.
2. Narrow, repeated judgments, where a small specialist can beat both
In September 2026 I benchmarked DeepSeek V4 Flash against Jev, a small hosted judge model from TypeSafe, on real data from my own Locul second brain. Two narrow tasks: deciding whether a new memory duplicates or replaces an old one, and deciding whether a note contains anything worth extracting.
| Task | Jev | DeepSeek V4 Flash |
|---|---|---|
| Duplicate or replace | 97% | 90% |
| Extract or skip | 98% | 91% |
| Time per call | About 0.5s | About 3s |
Jev also made no false merges of different people or companies. For narrow yes-or-no calls, a small specialist beat a large open generalist by seven points and ran about six times faster. Size the model to the job: “open versus closed” is the wrong first question when the task is small and repeated.
3. Data that is not allowed to leave
This is the one job where self-hosting is the requirement, not a saving, and it is the reason I first looked at open models in 2024. A hosted open model is just another vendor. Open weights only buy you privacy if you run them yourself. If that is your situation, start with the Apache 2.0 models that fit on hardware you control, and run the test below on your own documents before you promise a client anything.
Run this one-week test before you switch
Benchmarks did not change my mind; pushing about 50 million tokens through the model myself did. You do not need that volume, but you do need your own tasks. Copy this and fill it in:
ONE-WEEK OPEN MODEL TEST
Candidate model: ______________ (e.g. GLM-5.2 via Z.ai, or Qwen3.8-27B self-hosted)
Current model: ______________ (e.g. Claude Sonnet on a Max plan)
1. Pick 20 real tasks from last week. Not demos. Mix:
- 8 routine (summaries, rewrites, small fixes)
- 8 medium (a feature, a report, a multi-file change)
- 4 hard (the ones you would never trust to a junior)
2. Run each task on both models with the same prompt and the same files.
3. Score each run: PASS (shippable as-is) / FIX (needed my edits) / FAIL
4. Log minutes of your own time spent fixing each FIX and FAIL.
Switch rule (write yours down BEFORE you look at results):
- Switch routine work only if the candidate passes at least 7 of 8 routine tasks.
- Switch everything only if it matches your current model on the 4 hard tasks.
- Monthly saving must exceed (extra fix minutes x 4 weeks x your hourly rate).
The last line is the one that decided my GLM test. The model passed on quality; the saving did not beat the cost of my own time.
What Reddit gets right about open models
I read the recent r/LocalLLaMA and r/LocalLLM threads on this question, including the “have we reached good enough?” discussion that Google’s AI Overview cites. Five claims come up again and again.
“Open models are just good enough now.” Partly true. For routine work, yes, and GLM 5.2 cleared my bar for quality. For whole features, front end and back end together, I still use Claude, and I switch to Codex for complex backend work, as I explain in Codex vs Claude Code.
“Claude Code and Codex win on the harness, not just the model.” Correct, and you can separate the two. The DeepSeek wrapper above, and the GLM config in my coding plan review, put an open model inside the Claude Code harness, so you can test the model without losing the tooling.
“It is open weights, not open source.” Correct for almost every model on this list. See the licence table above; the licence matters more than the label.
“Local is free, private and never gets more expensive.” Free per token, not free. My 2024 estimate was $5,000 to $10,000 of hardware plus running costs, and the models that cleared my bar in 2026 do not fit on that hardware anyway. Private only if it is genuinely local.
“Use a frontier model as the director and open models as the workers.” This is the setup I would recommend. It is close to what I do: frontier models for the work that matters and a cheap open model API for long, trivial jobs. My own benchmark above suggests adding a small specialist for narrow judgments.
FAQ
What is the best open source LLM in 2026?
For real coding and agent work, GLM-5.2: it is the only open model I have rated between Claude 4.6 and 4.8. On Artificial Analysis’s open-weights leaderboard, Kimi K3.1 Pro currently scores highest, but I have not tested it and its licence has conditions. For self-hosting on one machine, look at Qwen3.8-27B or Gemma 4 31B.
What are the limitations of open source LLMs?
The flagship open models are too big to self-host cheaply, quality on hard multi-step work still trails the best frontier models, and you carry the deployment, security and update work yourself. The licences also vary more than the “open” label suggests.
What are the benefits of using open source LLMs?
Control over where your data goes when you host them yourself, no lock-in to one vendor, freedom to fine-tune, and much lower per-token prices on hosted open APIs for long, simple jobs.
What hardware do you need to run an open source LLM?
It depends on the model’s total parameter count. At 4-bit, a 27B model such as Qwen3.8-27B needs about 16 GB, while GLM-5.2 (753B) needs hundreds of gigabytes across several GPUs. The formula and tier table above let you check any model.
Are open source LLMs cheaper than Claude or ChatGPT?
Per token, usually yes. Against a flat subscription, often no. I run 15 to 20 billion tokens a month for about $500 to $600 on subscriptions, and saving $100 to $200 by switching to GLM was not worth working on a model I knew was not the best.
Can I use an open source LLM inside Claude Code?
Yes. Providers such as DeepSeek and Z.ai expose Anthropic-compatible endpoints, so you point Claude Code at them with a few environment variables. The shell function above does it for one session at a time, and Anthropic documents the general mechanism in its LLM gateway guide.
Where this comes from
I run nine products and my back office runs on scheduled Claude Code jobs, so I have used GLM through Z.ai’s coding plan and DeepSeek through its API on real work, not demos. I rejected open models for regulated-industry clients in 2024, then put about 50 million tokens through GLM 5.2 in 24 hours in 2026 and changed my mind on quality, if not on my subscription. The verdicts above are what I actually pay for this month: frontier subscriptions for the work that matters and the DeepSeek API for long, boring jobs. The benchmark ran on my own data in Locul, the local-first second brain I built so your notes and memories stay on your machine and reach Claude over MCP. If you route Claude Code to an open model, my free Claude skills still work, because they are plain instruction files that load whatever model sits behind it.