Updated October 2026 — the TSK-1 Benchmark findings are refreshed monthly.

"Open models cannot be just open. They have to be great."
— Zhilin Yang, Moonshot AI (Kimi K2.5 GTC 2026 keynote)

The best open source LLM in October 2026 is no longer a consolation prize. Open-weight models now sit one or two places behind the closed frontier on public leaderboards, the gap on everyday work is single-digit percentage points, and the cost per generation is often several times lower. For real work, that math matters.

This guide ranks the 10 open-source LLMs that ship real work in October 2026, what each is best for, the benchmark and leaderboard numbers worth knowing, the hardware each one needs (including the best local LLM picks for one GPU or a Mac), the self-host cost math, the license risk decoder, the new architectures behind the 2026 jump (Muon, Kimi Linear, Attention Residuals), real app-building results from the TSK-1 Benchmark, and how to mix all of it inside Taskade Genesis without touching infrastructure.

TL;DR: The strongest open-source LLMs in October 2026 are GLM-5.3 (the #1 all-rounder: 1M context, 45 on the Artificial Analysis open-weights index), Kimi K3 (top open model on LMArena, agentic coding leader: 2.8T open weights), DeepSeek V4.1 Flash and V4 Pro (code, math and price, MIT), Xiaomi MiMo-V2.6-Pro (46, the top open-weights index score, MIT), Qwen 3.8 (27B dense under Apache 2.0, the best single-GPU model), MiniMax M3 (long documents, native multimodal), Google Gemma 4 (the best local LLM family, Apache 2.0), Meta Llama 4 Scout (10M context), Mistral Large 3 (European languages, Apache 2.0) and Cohere Command A+ (retrieval and RAG, Apache 2.0). Taskade Genesis runs open-weight leaders such as Kimi, DeepSeek, GLM, MiniMax and Nemotron in one picker next to frontier models from top AI labs. No rebuilds when a new model ships.

What Is the Best Open-Source LLM in October 2026?

GLM-5.3 from Z.ai is the best open-source LLM for most work in October 2026. It ties for second on the Artificial Analysis open-weights Intelligence Index (45), ships a 1 million token window, and beats GLM-5.2 by about 20 points on the DeepSWE v1.1 coding test (66.9 vs 46.2). Pick Kimi K3 for long agentic builds, DeepSeek V4.1 Flash for price, and Qwen 3.8 27B or Gemma 4 for a single GPU.

The leaderboards agree on the top tier and disagree on the order. On Artificial Analysis (Intelligence Index v4.3.2, checked October 20, 2026), MiMo-V2.6-Pro scores 46, DeepSeek V4.1 Flash 1017 and GLM-5.3 score 45, and Kimi K3 scores 44. On LMArena (text leaderboard, updated October 15), human voters put Kimi K3 first among open models at 1487, with MiMo-V2.6-Pro and GLM-5.3 tied at 1479. Our ranking weighs those two signals plus license, hardware, and what each model actually built in the TSK-1 tests.

Turn a prompt into a working app: Taskade Genesis builds a live app with AI agents and automations from plain English. The Free plan includes 3 apps. Start with one prompt →

What Changed Since August 2026: The New Open-Source LLM Release Log

The ten weeks from August to October 2026 brought a dense run of open-weight releases. Four of them changed this ranking: GLM-5.3 replaced GLM-5.2 at #1, DeepSeek V4.1 Flash joined V4 Pro, Xiaomi MiMo-V2.6-Pro entered at #4, and Qwen 3.8 took over the Qwen slot. Three names are new to the ten: MiMo-V2.6-Pro and Google Gemma 4 replace MiniMax abab and Microsoft Phi-4 (Phi-4 now appears in the local LLM section), and Cohere Command A+, the Apache 2.0 successor released in May, replaces Command R+.

Sources: each lab's model card or release note (DeepSeek news, Z.ai GLM-5.3, Qwen 3.8 27B, Mistral Large 4, Meta Muse Spark Open, NVIDIA Nemotron 3.5). For the full lineage behind these names, read the open-source LLM history.

Earlier in 2026: the moves that set up this ranking

Five dated moves from May to July built the field this October list inherits:

• July 16, 2026 — Moonshot shipped Kimi K3, a 2.8-trillion-parameter open-weight mixture-of-experts model (about 104B active per token) with native vision and a 1-million-token window, the largest open-weight model released to date. The weights and tech report landed on Hugging Face on July 27 under Moonshot's own Kimi K3 License. See the Moonshot AI & Kimi history.
• June 12, 2026 — Moonshot shipped Kimi K2.7 Code: +21.8% over K2.6 on Kimi Code Bench v2, plus a HighSpeed variant with ~6× faster inference.
• June 13, 2026 — Zhipu released GLM-5.2; MIT weights landed on Hugging Face around June 16. It held #1 until GLM-5.3 arrived in August.
• June 2026 — MiniMax M3 posted 59.0% on SWE-bench Pro with a 1M-token window and native multimodal input.
• May 19, 2026 — Qwen 3.7 Max shipped API-only. It is not open-weight. The open Qwen line moved from Qwen 3.6 (April 2026, Apache 2.0) to Qwen 3.8 in August.

▲ ■ ● The Quick Read

Three lines. Then dig deeper if you want.

▲  Open-source LLMs in 2026 are good enough for 90% of real work.
■  The other 10% still wants premium frontier models.
●  Taskade Genesis offers both. One picker. One credit system. One workspace.

That is the whole article. Everything below is the rationale, the rankings, and the patterns that work.

How Do I Use These Open-Source Models Without Self-Hosting Them?

Taskade Genesis puts frontier models from top AI labs, including open-weight Kimi, DeepSeek, GLM, MiniMax and Nemotron models, behind one picker inside the same AI agents and automations already in your workspace. Leave it on Auto and Taskade routes each task; no GPU rental, no Kubernetes, no version drift to track.

• One picker, no self-hosting: pin an exact model on any agent, and switch anytime.
• Auto routing: leave model choice on Auto and Taskade routes the task for you. An AI step in an automation runs on Auto or a TSK rung.
• Credits you can see: the usage chip on each message shows the credits that turn used, and each model card shows speed, intelligence and token-usage bars.
• Your own key: on Business and up, a Together AI, Groq or Mistral key runs more open-weight models on your own provider account.
• Free plan: starts with no AI credits (earn credits or buy a credit pack), no credit card required.
• Pro: $10/month billed annually — 50,000 credits/month.

Taskade is not the only way to run open-weight models without hardware. The no-code builders that run open-weight models guide compares the other options, and AI builders with your own key covers the platforms that accept your own provider key.

Try the model picker free →

Quick Comparison Table (Ranked)

The table you came here for, split into three mobile-friendly views of the same ten models. Every figure is as of October 20, 2026.

What each model wins at

Size, context and the headline number

How to run them inside Taskade: DeepSeek V4 Pro and MiniMax M3 run on Taskade credits on every paid plan, and Kimi K3 and GLM 5.3 on Max and Enterprise. The rest run on your own provider key or locally. The run-it-in-Taskade table maps each path to its plan, and the key providers page lists the models each key serves.

Five numbers worth committing to memory.

✓ MiMo-V2.6-Pro scores 46 on the Artificial Analysis open-weights Intelligence Index, the top open score on October 20, 2026. DeepSeek V4.1 Flash 1017 and GLM-5.3 follow at 45, Step 5 Preview and Kimi K3 at 44. All five come from Chinese labs.

✓ Kimi K3 is the top open model on LMArena at 1487 (text leaderboard, updated October 15, rank 18 overall), and at 2.8 trillion parameters it is still the largest open-weight model released to date.

✓ Qwen 3.8 27B reports 61.7% on SWE-bench Pro from a 27B dense model under Apache 2.0. That beats the 58.6% that Kimi K2.6 set in April, when it led the premium frontier field as it stood then (GPT-5.4 57.7, Claude Opus 4.6 53.4, Gemini 3.1 Pro 54.2), and the model fits one 24 GB GPU at 4-bit.

✓ GLM-5.2 scored 91.2% on GPQA Diamond in June, and GLM-5.3 lifted DeepSWE v1.1 from 46.2 to 66.9 two months later. Open-weight models caught up on graduate-level reasoning, then on agentic coding.

✓ Qwen family crossed 700M Hugging Face downloads in January 2026 with 113,000+ derivative models. The most-downloaded open model family ever.

Benchmark numbers are the latest published scores from each lab's model card, plus the two public leaderboards, as of October 20, 2026. Lab-reported numbers come from each lab's own test setup. Treat them as direction, not gospel, and run the model on your own work for the real answer.

The Taskade model directory keeps one page for each model Taskade runs, with its plan, release date, context window and TSK-1 result.

Open-Source LLM Leaderboards in October 2026

Two public leaderboards matter most for open-weight models in October 2026. Artificial Analysis runs the same test suite on every model and publishes an Intelligence Index. LMArena ranks models by blind human votes. Both show the same top tier of open models, led by Chinese labs, with Meta's new Muse Spark Open as the best-placed US model.

Artificial Analysis open-weights Intelligence Index (v4.3.2, checked October 20, 2026, source):

LMArena text leaderboard, open models only (updated October 15, 2026, source):

Three things the two boards tell you. The top of the open field is crowded, so a 1-point index gap or a 5-point arena gap is noise, not a verdict. Speed varies far more than quality: the listed output speeds span from 42 to over 1,000 tokens per second, and the same weights run at very different speeds on different hosts (see the Kimi K3 host table below). And neither board measures whether a model can finish a real job, which is what the next section covers.

The TSK-1 Benchmark: Real-Work Proof, Not Model Cards

Model cards tell you what a lab tested. The TSK-1 Benchmark tells you what a model actually built — it grades models on whether they build complete working apps, checking whether the app opens and runs, whether it built what was asked for, whether it looks right, and whether the data actually saves. See the dated evidence at /tsk. Two findings from recent tests, both from models on this list:

• DeepSeek V4 Flash: "the cheapest model built the best-looking app" (Aug 1, 2026) — one coherent look in both light and dark, nothing broken in the browser, and a clean layout on a phone.
• Kimi K3: the fewest failed steps of the models tested that day (7.2%, Jul 31, 2026) — the open-source model that gets in its own way least while building.

No other ranking of open-source LLMs tests what the models build. The leaderboards above score answers to questions. TSK-1 hands each model the same plain-English app request inside Taskade Genesis, then opens the result and uses it. Here is where the open-weight models stood after the October round:

On the family scoreboard, the two open-weight leaders, DeepSeek and Kimi, tie Claude at 75 out of 100, 13 points behind GPT, and GLM scores 63. On real app building, open-weight models are now level with the second tier of premium models.

Two lessons carry over to any open model you test yourself. First, a model that tops a leaderboard can still stall on delivery: DeepSeek V4 Pro wrote some of the deepest data layers of the whole test and still left apps locked. Second, cheap does not mean weak: the economical DeepSeek Flash line built the best-looking and the richest apps in two separate rounds. The Qwen results cover Qwen 3.7 Plus and Max, which are API-only models, so they say little about the open Qwen 3.8 weights.

Why Open-Source LLMs Matter in 2026

The 2024 narrative said premium frontier models would stay one full generation ahead of open-source forever. The 2026 reality is more nuanced.

                  reasoning  code   long-ctx  multilingual  cost
  premium models     ████    ███      ███         ███        $$$
  open-source 2026   ███▌    ███      ████        ███▌        $
  open-source 2024   ██▌     ██       ██          ██          $

Three reasons the gap narrowed.

✓ The compute moat shrank. Mixture-of-experts architectures and better training data closed most of the quality gap at a fraction of the parameter count.

✓ The open community ships faster. Frontier-class open-weight releases shipped nearly every month through the first half of 2026 — three in June alone (Kimi K2.7 Code, GLM-5.2, MiniMax M3), then Kimi K3 in July.

✓ The use cases changed. Real production workloads are 80% routine and 20% hard. Open-source handles the routine 80% beautifully.

The right mental model in 2026 is portfolio, not pick-one. Use premium models for the hardest 20%. Use open-source for the routine 80%. Taskade Genesis makes that mix one click.

Mixture-of-Experts vs Dense: Why the 2026 Champions Are All Sparse

Every family in the October top ten ships a Mixture-of-Experts model, including Meta's Llama 4 Scout (109B total, 17B active, 16 experts). Only two lead with a dense flagship: Qwen 3.8 27B and Gemma 4 31B, the two models built to fit one GPU. The split is not an accident. Sparsity is what makes the cost-per-quality math work at scale, and density is what makes a small model easy to run at home.

In plain terms.

✓ Dense loads every parameter for every token. Predictable, well-understood, slower per parameter.

✓ Mixture-of-experts computes only the experts the router picks. Same model card, a fraction of the compute per token.

The practical result is a Kimi K3 that carries 2.8 trillion total parameters while using 16 routed + 2 shared of its 896 experts per token (about 104B active, roughly 3.7%), or a DeepSeek V4.1 Flash that computes only 8B to 16B of its 552B backbone parameters per token and still ties GLM-5.3 on the open-weights index. Sparsity is why 2026's open-source champions punch above weight class.

Memory check: total parameters, not active ones, set the GPU memory. Kimi K3 computes about 104B parameters per token, but a server still has to hold all 2.8T in GPU memory. At production batch sizes every expert is busy at some instant, and swapping experts in and out breaks latency targets. So the compute bill looks like a ~100B model while the memory bill is the full 1.56 TB MXFP4 checkpoint, which needs at least one 8× B300 node.

For builders inside Taskade Genesis, this is mostly invisible. The model catalog groups each model into a Low, Medium or High cost band, and Auto handles the default on any agent you do not pin. But understanding the why behind the prices helps you reason about which model to pin on a hot path. If you want to see how these families perform on a real build rather than a benchmark, we gave nine of them the same app request and graded what came out: best AI model for building apps. For how these models are trained on graded real work in the first place, see RL environments explained.

Every model on this list, dense or sparse, is a transformer underneath. If attention, layers and the residual stream are new to you, Grant Sanderson's talk is the clearest visual introduction we know, and it makes the Kimi Linear and Attention Residuals changes later in this guide much easier to follow:

For a plain-language glossary of the terms in this section, see mixture of experts and large language models in the Taskade wiki.

Self-Host TCO vs Taskade Genesis Gateway

The other math you came here for. If you were going to run these models yourself, what hardware would you need, and how does that compare to running them through the Taskade Genesis managed gateway?

Worth knowing what a rented GPU-hour is actually paying for: how AI data centers work breaks down the power, cooling, and memory bandwidth behind a rented accelerator — and why memory, not compute, sets how many tokens per second you get out of one. The GPU and HBM wiki pages cover the hardware itself.

The rule that decides everything: the weights must fit in memory first. Weight memory is roughly the parameter count times the bits per weight, divided by 8. Add 10-30% for the context cache and the runtime. For a mixture-of-experts model, use the total parameter count, not the active one.

  WEIGHT MEMORY ≈ total parameters × bits per weight ÷ 8
  model                  params     16-bit      8-bit      4-bit
─────────────────────  ───────    ───────    ───────    ───────
Phi-4                    14B        28 GB      14 GB       ~8 GB
Qwen 3.8 27B             27B        54 GB      27 GB     ~15 GB
Gemma 4 31B              31B        62 GB      31 GB     ~17 GB
Llama 4 Scout           109B       218 GB     109 GB     ~60 GB
GLM-5.3                 753B      1.5 TB      753 GB    ~400 GB
DeepSeek V4 Pro         1.6T      3.2 TB      1.6 TB    ~850 GB
Kimi K3                 2.8T       —          —        1.56 TB (native MXFP4)

context cache and runtime: add 10-30% on top

Hardware you need for each model (our estimates from the formula above, weights at 4-bit unless noted):

Where each one is practical to run:

Why Kimi K3 needs a B300 node. The K3 checkpoint ships in native MXFP4 weights at about 1.56 TB. Eight B300 GPUs hold about 2.3 TB of HBM3e (288 GB each), so the model fits with room for the cache. Eight B200s hold 1.44 TB and eight H100s hold 640 GB, so neither fits. For what tokens per second means in practice, see tokens per second.

What these tables are saying.

✓ Self-hosting a small open model is genuinely cheap: a 24 GB GPU or a 32 GB Mac runs the best single-GPU models of 2026 at no per-token cost.

✓ Self-hosting a frontier-class open model is an infrastructure project. Every model in the top five needs a multi-GPU node, so most teams rent it through a host or a managed gateway.

✓ Open-weight models on a managed gateway get you most of the cost benefit without the operational tax of running the servers yourself.

The Taskade Genesis math is simpler. Open the picker. Pick the model. Run the prompt. The usage chip on each message shows the credits that turn used.

How Fast Is an Open-Source LLM? It Depends on the Host

The same open weights run at very different speeds on different hosts. On Artificial Analysis (median output speed with a 10,000-token input, checked October 20, 2026), Kimi K3 ranged from 42 tokens per second on Moonshot's own API to 422 on the fastest host, about a 10× spread for identical weights:

  KIMI K3 OUTPUT SPEED BY HOST (tokens per second, median)
  LithosAI (Ultra Chat)  ██████████████████████████████████████████  422
Inco (Fast)            █████████████████████████████████████       366
Parasail               ████████████████████                        198
Nebius                 ███████████████████                         192
Amazon Bedrock         ██████████████                              142
Modal                  ██████████████                              141
Databricks             ████████████                                116
Fireworks              ███████████                                 112
Baseten                ██████████                                   96
DigitalOcean           ██████                                       58
Together AI            ██████                                       57
Moonshot (first-party) ████                                         42

The gap comes from serving choices, not the model: how the host splits the model across GPUs, whether it separates prompt processing from token generation, and whether it runs a speculative decoder. Baseten's engineers walk through exactly those choices for trillion-parameter models in this talk:

For the serving side in depth, read AI inference explained and inference as a service. If 20 tokens per second sounds slow or fast to you, the tokens per second page puts the number in context.

License Risk Decoder

The part no one explains in plain language. Here is what each license actually means for your business.

Qwen: which ones are open? Alibaba shipped Qwen 3.7 Max on May 19, 2026 as a proprietary, API-only model, and Qwen 3.7 Plus is API-only too. Any page calling Qwen 3.7 "open-source" is wrong. The open-weight Qwen line is Qwen 3.6 (35B-A3B mixture-of-experts and 27B dense, April 2026, both Apache 2.0) and now Qwen 3.8: the 27B dense model under Apache 2.0, and the first downloadable Max-class model, Qwen 3.8 2.4T-A95B (August 12, 2026), under its own custom license. The open 2.4T weights are text-only. The API version adds vision.

The two-question rule for any open-source LLM you ship in production.

1. Can I use the weights or only the API? MIT/Apache 2.0 = weights are yours (DeepSeek V4 and V4.1, MiMo-V2.6-Pro, GLM-5.2, Qwen 3.8 27B, Qwen 3.6, Gemma 4, Mistral Large 3, Command A+, Phi-4; Kimi K2.7 Code under Modified MIT). Custom terms = weights are yours with conditions (GLM-5.3, Kimi K3, MiniMax M3, Qwen 3.8 Max, Muse Spark Open). Command R+ weights = research only. Qwen 3.7 Max and Plus = API only. Mistral Large 4 = API preview until its weights ship.
2. Can I redistribute a fine-tune? MIT/Apache = yes. Llama = yes under the 700M MAU cap measured at the parent corporate entity in April 2025 (frozen, not rolling). Command R+ = no for the weights. Custom licenses = read the clause.

For most teams, MIT and Apache 2.0 models (DeepSeek V4.1 Flash, MiMo-V2.6-Pro, Qwen 3.8 27B, Gemma 4, Command A+) are the cleanest commercial-use story in 2026. GLM-5.3 and Kimi K3 are open-weight on their own terms, which is a legal-review step rather than a blocker for almost every company. Inside Taskade Genesis the license question is handled at the gateway level: you use the models in the picker without dealing with redistribution rules.

How K2.5 Got Great: Three Scaling Dimensions Worth Stealing

The clearest signal that open-source LLMs are no longer playing catch-up in 2026 is Kimi K2.5. The architecture is so good that Moonshot AI's founder, Zhilin Yang, walked through it at GTC 2026 as three independent scaling dimensions, each delivering a multiplier on the next.

Worth understanding the shape of it. Most listicles skip this. We won't.

Yang's full keynote is worth the time if you build on these models. It is the most detailed public account of how a Chinese open-weight lab trains at trillion-parameter scale:

▲ Dimension 1: Token Efficiency (Muon optimizer)

Yang's team replaced AdamW (the 2014 default) with the Muon optimizer, the first scaled production use of Muon in LLM history. Result: 2× token efficiency. 50 trillion high-quality tokens behave like 100 trillion.

That sounds like infrastructure. It isn't.

"Token efficiency is not just about efficiency. It is actually about improving the upper bound of intelligence... we are hitting the data wall and the amount of high-quality data is quite limited."
— Zhilin Yang, GTC 2026

When training data is finite, doubling token efficiency doubles the ceiling. The technical wrinkle that made this work at 1 trillion parameters: QK-Clip. Without it, max logits exploded past 1,000 (normal: ~50). With it, training curves look identical, training stays stable.

■ Dimension 2: Context Length (Kimi Linear)

Kimi Linear is a new attention architecture. 1:3 ratio of full attention to Kimi Delta Attention layers, with a per-channel decay matrix instead of a scalar. The result is the first architecture to outperform full attention on all three counts at once: short context, long input, long output.

For builders, this is the architecture that let the Kimi K2.6 / K2.7 Code line hold its 256K production window, and that the K3 generation carried to a full 1 million tokens in production without falling apart at the back of the prompt. Long context that actually reasons.

● Dimension 3: Agent Swarms (Orchestrator + Sub-agents)

The third scaling dimension is not architectural. It is organizational.

Moonshot trains the swarm with three reward functions: an instantiation reward (so the orchestrator does not collapse to single-agent mode), a finish reward (so it does not spawn pseudo-tasks), and the standard outcome reward. Decayed over training.

This is precisely the shape of Multi-Agent Teams inside Taskade Genesis. Your orchestrator agent assigns work to sub-agents, each with its own model, tools, and memory. Results aggregate back. The open-source research is converging on the same pattern Taskade ships.

"This is one of the most beautiful curves I observed in my life... over 15 trillion tokens and the entire training process is just so stable. No loss spike."
— Zhilin Yang, on the K2.5 training run

The takeaway for builders. Architecture progress is no longer rare. Adam (2014), full attention (2017), residual connections (2016): all three got challenged successfully in 2026. The open community ships the next layer of the foundation while the closed labs argue about pricing.

A Short History of How We Got Here

A timeline of the open-source LLM movement, from the first weights drop to the 2026 inflection.

In four years the open-source category went from research experiments to production default for most everyday workloads, and in the ten weeks from August to October 2026 alone, four labs (Xiaomi, DeepSeek, Z.ai and StepFun) shipped open models that score within two points of each other at the top of the open-weights index. For the complete story — from GPT-2's cautious 2019 release through BLOOM, LLaMA, and DeepSeek to the 2.8-trillion-parameter Kimi K3 — see our full history of open-source LLMs, and the deep dive on Moonshot AI and Kimi.

How the Ten Map to Your Workloads

Every team's workload distribution is different. Three common shapes, and which open-source pick fits each.

Now the deep dives, one model at a time.

1. GLM-5.3: The Best Open-Source LLM for Most Work

Maker: Zhipu AI (Z.ai). Released: August 14, 2026 (API), with open weights on Hugging Face later in August. License: the GLM-5.3 License, an MIT-style grant with one gate for very large model-as-a-service businesses (see the License Risk Decoder). Architecture: Mixture-of-experts, 753B total parameters. Context: 1 million tokens, with up to 131K tokens of output.

October 2026 standing: 45 on the Artificial Analysis open-weights index (tied for second) · 1479 on LMArena (third among open models) · Z.ai-reported Terminal-Bench 2.1 88.2 and DeepSWE v1.1 66.9, up from 81.0 and 46.2 on GLM-5.2.

GLM-5.3 holds the #1 spot because it is the most balanced model on the list. It is not the top scorer on any single board: MiMo-V2.6-Pro edges it on the index and Kimi K3 edges it on LMArena. But it is within a point of the leader on both, it is the strongest open model on long agentic coding runs that Z.ai measured, and its license works like MIT for every company below 10 billion US dollars in model-as-a-service revenue. If you want one open-weight default and do not want to think about it again this quarter, this is the one.

The jump from GLM-5.2 is the agentic part. On Z.ai's own comparison table, Toolathlon Verified rose from 59.9 to 73.0, AutomationBench from 26.2 to 48.2, and HLE with tools from 54.7 to 62.5. Z.ai also says the model improves on GLM-5.2 by 50% on its internal code benchmark. Those are lab-reported numbers from Z.ai's own test setups, so read them as direction. The independent index and the arena votes both moved the same way.

GLM-5.2 is still worth knowing. Released June 13, 2026 under a plain MIT license, it scored 91.2% on GPQA Diamond and matched or beat GPT-5.5 on long-horizon coding tasks at roughly 1/6 the cost. It sits at 1476 on LMArena, three points behind GLM-5.3. If your legal team wants MIT and nothing else, GLM-5.2 is the pick. For a cheap, fast sibling, GLM-5.3-Flash (MIT) scores 42 on the open-weights index and is the budget GLM for drafts, titles and summaries.

What it is great at

✓ Broad reasoning where you want a single open-source default

✓ Long-horizon coding and multi-step agent tasks with tools

✓ Workflows that ingest long documents under 1M tokens

✓ Commercial deployments where an MIT-style license removes legal-review friction

Where it is not the best pick

• Bulk classification at the lowest price (GLM-5.3-Flash or DeepSeek V4.1 Flash are cheaper)
• Laptops and phones (use Gemma 4 or Qwen 3.8 27B)
• A cloud provider above the $10 billion revenue gate that wants to resell inference without a Z.ai review

Run it yourself

The weights need about 400 GB at 4-bit, so a single 8× H100 node is the practical floor, and 8× H200 runs it at 8-bit. Most teams use a host instead: the GLM 5.3 model page lists the services that serve it, including Z.ai's own API, Amazon Bedrock, Baseten and Cloudflare Workers AI. Artificial Analysis lists it at 86 output tokens per second.

Inside Taskade Genesis

GLM 5.3 and GLM 5.2 run on Taskade credits on Max and Enterprise; the model catalog rates both Slow, Frontier intelligence and Medium cost, and GLM in Taskade covers the setup. On Business and up, a Together AI key also serves GLM 5.2 for custom agents and Ask Agent. Pin GLM 5.3 on any agent that does research, drafting or routing decisions. In the TSK-1 Benchmark, GLM earned its reputation as "the model that said no": it considered adding a sign-in screen the brief had not asked for and offered it as a suggestion instead.

2. Kimi K3: The Agentic Coding Champion

Maker: Moonshot AI. Released: July 16, 2026 (API), with open weights on Hugging Face on July 27. License: Kimi K3 License (Moonshot's own document, not MIT; self-hosting permitted, commercial-inference clause above a large annual-revenue threshold). Architecture: Mixture-of-experts, 2.8 trillion total parameters, 16 routed + 2 shared of 896 experts used per token (about 104B active). Context: 1 million tokens, with native vision.

Spec line: Attention Residuals in place of the plain residual sum · 1,048,576-token context · native MXFP4 weights (about 1.56 TB). Full numbers on the Kimi K3 model page.

October 2026 standing: 1487 on LMArena, the top open model (rank 18 overall) · 44 on the Artificial Analysis open-weights index · Terminal-Bench 2.1 88.3 in Z.ai's GLM-5.3 comparison table, the highest open score in that table.

Benchmark snapshot (July 2026 release):

• The largest open-weight model released to date at 2.8T total parameters
• Predecessors Kimi K2.7 Code (June 12, 2026, +21.8% over K2.6 on Kimi Code Bench v2) and Kimi K2.6 (April 20, 2026, SWE-bench Pro 58.6%)

The K2.6 line took the agentic-coding lead from premium frontier labs in April, K2.7 Code specialized it in June, and K3 in July did the thing open-weight models were not supposed to do: it shipped at frontier scale with the weights attached.

The architectural point is the sparsity: about 3.7% of the weights fire per token, so the compute per token tracks a ~100B model rather than a 2.8T one, the same lever behind DeepSeek V4, applied at a larger total size. Every expert still has to sit in GPU memory. The attention design carries forward from Kimi Linear: 69 Kimi Delta Attention layers and 24 Gated MLA layers in a 3:1 pattern, which keeps the million-token window coherent through a long agent trajectory.

Read the license before you ship: the Kimi K3 License is a different document from the Modified MIT that covered K2.6 and K2.7 Code, so the old terms did not carry over.

What it is great at

✓ Agentic coding on real software tasks

✓ Multi-tool tool calling with stable behavior across long trajectories

✓ Million-token context that holds reasoning quality to the end of the window

✓ Native vision, so screenshots and diagrams enter the same prompt as the code

Where it is not the best pick

• Whole-codebase prompts over 1M tokens (use Llama 4 Scout's 10M window for ingest, then hand off to Kimi)
• Broad non-coding reasoning (GLM-5.3 is the stronger generalist)
• Tight, latency-bound agent loops (K2.7 Code HighSpeed runs roughly 6x faster on a 256K window)

Run it yourself

The 1.56 TB MXFP4 checkpoint needs one 8× B300 node at minimum and does not fit an 8× H100 or 8× B200 node, so K3 is a hosted-API model for all but the largest infrastructure teams. Host speed varies about 10× (see the host table).

Inside Taskade Genesis

Kimi K3 reaches Taskade by two paths. On Taskade credits it is in the model picker on Max and Enterprise. On Business and up you can also add a Together AI key under AI Model Keys and pick Kimi K3 for custom agents and Ask Agent; an agent chat on your own key uses no Taskade credits. The key walkthrough shows the steps.

Set Kimi K3 as the model on any agent that needs to drive multi-step tool use: code-editor agents, sales-outreach agents, multi-stage research agents. In the TSK-1 Benchmark, only 7.2% of Kimi K3's build actions failed in one round (Jul 31, 2026), the most reliable result of that test, and its September sales CRM scored all eight sample leads. The trade-off is time: the TSK-1 verdict is that K3 "builds more than almost any model and finishes later than all of them," and three September tests reached the 40-minute limit before a closing summary. Kimi in Taskade covers the setup.

3. DeepSeek V4.1 Flash and V4 Pro: Code, Math and Price

Maker: DeepSeek AI. Released: DeepSeek V4.1 Flash on September 10, 2026, updated as V4.1 Flash 1017 on October 17. DeepSeek V4 Pro as a preview on April 24, 2026, and as a general release on August 13. License: MIT for both (clean commercial use, no MAU clause). Architecture: V4.1 Flash is a mixture-of-experts with a 552B-parameter backbone that computes 8B parameters per token while reading the prompt and 16B while writing, plus a 196B-parameter conditional memory module; V4 Pro is 1.6T total, 49B used per token. Context: 1 million tokens for both. V4.1 Flash also reads images.

October 2026 standing: V4.1 Flash 1017 scores 45 on the Artificial Analysis open-weights index, tied with GLM-5.3, at a listed 211 output tokens per second · DeepSeek-reported GPQA Diamond 90.9, Terminal-Bench 2.1 90.6, DeepSWE v1.1 74.2, Codeforces rating 3471 · V4 Pro holds SWE-bench Verified 80.6% from its April card.

DeepSeek is the open-source family engineers reach for when the work is code or quantitative, and in October 2026 it is also the family that makes frontier-tier open models cheap. V4.1 Flash is the surprise of the autumn: a "Flash" model that ties the GLM flagship on the independent index while computing a fraction of the parameters per token. V4 Pro remains the deeper model for heavy data work, and its August general release added selectable reasoning effort and native support for the OpenAI Responses API. V4 introduced Compressed Sparse Attention, running at 27% of V3.2's FLOPs and 10% of its KV-cache memory, and DeepSeek R1 remains the most-liked model in Hugging Face history.

The TSK-1 results match the leaderboard story. V4.1 Flash built the richest app per brief among the economical models: a six-page sales CRM whose scoring automation scored all 7 sample leads, and a four-page cookbook with both automations live. V4 Pro builds the deepest data layers of any model we test, with a record 60 fields in one round, but it has left apps behind a sign-in screen. Its predecessor V4 Flash won our design test in August as the cheapest model on the board.

What it is great at

✓ Code generation, refactoring and code review, with competition-level coding scores

✓ Mathematical reasoning, formula extraction, financial modeling

✓ Structured data extraction from messy inputs, now including images on V4.1 Flash

✓ High-volume runs where cost per generation matters

Where it is not the best pick

• Whole-codebase prompts beyond 1M tokens (use Llama 4 Scout's 10M window)
• Video or audio input (use MiMo-V2.6-Pro or MiniMax M3)
• Running at home: even V4.1 Flash needs about 380 GB at 4-bit

Run it yourself

V4.1 Flash fits an 8× H100 node at 4-bit or an 8× H200 node at 8-bit. V4 Pro needs about 850 GB at 4-bit, which means an 8× B200 node. Both run on many hosts, including DeepSeek's own API, Baseten, CoreWeave and DeepInfra. The DeepSeek V4.1 Flash page and the DeepSeek V4 Pro page list where each one runs.

Inside Taskade Genesis

DeepSeek V4 Pro runs on Taskade credits on every paid plan, in the Low cost band of the model catalog, and DeepSeek in Taskade covers the setup. Set it on a code-heavy agent, and pair it with Taskade EVE for the build. Connecting Claude Desktop or Cursor through the Taskade MCP Server works differently: the model already running in that client does the code work, then calls Taskade's tools to inspect the app and write the files back. Taskade adds no second model on that path. The result is a coding pipeline where your client handles the conversation and the workspace handles the file edits.

4. Xiaomi MiMo-V2.6-Pro: The Open-Weights Index Leader

Maker: Xiaomi MiMo team. Released: September 2026, the flagship of the MiMo-V2.6 series. License: MIT. Architecture: Mixture-of-experts, 1.02T total, 42B used per token, plus a 681M-parameter vision encoder, audio encoders of about 435M parameters, and a 5-layer multi-token prediction decoder that speeds up generation. Context: 1 million tokens. Input: text, images, video and audio.

October 2026 standing: 46 on the Artificial Analysis open-weights index, the top open score · 1479 on LMArena, tied with GLM-5.3 for second among open models · Xiaomi-reported Terminal-Bench 2.1 89.9, OSWorld-Verified 82.0, Toolathlon-Verified 76.9 and DeepSWE v1.1 71.9.

MiMo-V2.6-Pro is the model most English-language lists have not caught up with yet. Xiaomi, better known for phones, released its first open MiMo models in 2025 and shipped MiMo-V2.5-Pro under MIT in April 2026 (1467 on LMArena). Five months later V2.6-Pro took the top spot on the independent open-weights index with an MIT license, which no other model in the top five can claim alongside a 1M window and four input types.

The strongest signal is computer use. An OSWorld-Verified score of 82.0 means the model completed most of a test suite of real desktop tasks by operating the screen, and Toolathlon-Verified at 76.9 measures long chains of tool calls. Those are the skills an agent needs when it works through other software rather than answering questions. It ranks #4 here rather than #1 for two reasons: we have not run it through a TSK-1 build yet, and the listed output speed (50 tokens per second) is among the slowest of the top tier.

Xiaomi's position is also a signal about the market. All five of the top five open-weight models on the October index were released or updated in the past four months, and most of their labs published weights within weeks of the API. For a buyer, that means the open tier now refreshes faster than most annual vendor reviews, which is one more reason to keep model choice per agent rather than per contract.

What it is great at

✓ Computer-use and tool-heavy agents (OSWorld-Verified 82.0)

✓ Mixed inputs: screenshots, recordings and voice notes in one prompt

✓ Teams that need an MIT license at the top of the index

✓ Code agents on terminal tasks (Terminal-Bench 2.1 89.9)

Where it is not the best pick

• Latency-sensitive chat (DeepSeek V4.1 Flash is listed about 4× faster)
• Proven app-building results (no TSK-1 run yet; Kimi K3 and DeepSeek have one)
• Single-GPU or laptop use (it needs a multi-GPU node)

Run it yourself

The weights need about 550 GB at 4-bit, so plan on an 8× H200 node, or 8× H100 at 4-bit with a short context. The multi-token prediction decoder helps throughput once it runs. Hosted APIs carry the MiMo line, and Xiaomi publishes the weights on Hugging Face.

Inside Taskade Genesis

MiMo-V2.6-Pro is not in the Taskade model picker today. On Business and up you can run it in an automation through an OpenRouter provider step on your own key, if OpenRouter lists the model. Your provider bills each model call and the step uses one fixed step fee in Taskade credits. For an agent at the same tier on Taskade credits, pick Kimi K3 or GLM 5.3 on Max and Enterprise. The open-model builders guide compares other ways to run MiMo without hardware.

5. Qwen 3.8: The Open-Weight Multilingual Standard

Maker: Alibaba Cloud. Released: Qwen 3.8 2.4T-A95B open weights on August 12, 2026, and Qwen 3.8 27B in mid-August. License: Apache 2.0 for the 27B; a custom Qwen 3.8 Max license for the 2.4T. Architecture: the 27B is a dense 64-layer model that mixes Gated DeltaNet linear attention with gated attention; the 2.4T is a mixture-of-experts with 512 experts, 10 routed and 1 shared per token, about 95B active. Context: 262K tokens natively, up to 1 million with YaRN scaling.

October 2026 standing: Qwen-reported SWE-bench Pro 61.7, GPQA Diamond 89.2, LiveCodeBench v6 90.3 and OSWorld-Verified 84.3 for the 27B · 34 on the Artificial Analysis open-weights index for the 27B, the highest score for any model that fits one consumer GPU.

One naming correction up front, because half the internet gets it wrong: Qwen 3.7 Max and Qwen 3.7 Plus are not open-weight. Qwen 3.7 Max shipped May 19, 2026 as an API-only proprietary model (see the License Risk Decoder callout above). The open Qwen line runs Qwen 3.6 (April 2026) and now Qwen 3.8, and it is still one of the best reasons to run open models.

Qwen 3.8 27B is the most important small model of the autumn. A 27B dense model scoring 61.7 on SWE-bench Pro would have beaten every premium frontier model as they stood in April 2026, and it fits in about 15 to 17 GB at 4-bit. It also reads images and video. The 2.4T-A95B is the other end: the first Max-class Qwen you can download, text-only and always in thinking mode, at about 4.89 TB in BF16. The open weights do not include the vision and native 1M context of the API version.

The Qwen family is the most-downloaded open model family ever: 700 million+ Hugging Face downloads as of January 2026 and 113,000+ derivative models. Qwen keeps the family's strengths — multilingual coverage across dozens of languages, reliable tool calling, structured output that respects JSON Schema. The older Qwen 3.6 35B-A3B mixture-of-experts uses roughly 3B parameters per token and remains one of the cheapest models to self-host.

What it is great at

✓ Multilingual content across dozens of languages

✓ Coding and computer-use agents on one GPU (the 27B)

✓ Tool calling and structured output for AI agents

✓ Fine-tuning, with the largest derivative ecosystem of any model family

Where it is not the best pick

• The hardest reasoning tasks (GLM-5.3, Kimi K3, or premium frontier)
• Native 1M-token work on the open 2.4T weights (use the API or another 1M model)

Run it yourself

Qwen 3.8 27B runs on one 24 GB GPU or a 32 GB Mac at 4-bit through Ollama, LM Studio, llama.cpp or vLLM. The 2.4T-A95B is a data-center model: community GGUF builds run from about 397 GB to 1.31 TB.

Inside Taskade Genesis

The Qwen models in the Taskade picker are the API-only Qwen 3.7 Plus (every paid plan) and Qwen 3.7 Max (Max and Enterprise). In the TSK-1 Benchmark, Qwen 3.7 Plus finished a 32-question client sign-up form with every answer saved at a fraction of the usual cost. To run the open Qwen 3.8 weights in a workflow, use an OpenRouter provider step on your own key on Business and up, or run the 27B locally. A Chinese sales agent, a Japanese support agent and an English research agent can share one workspace with Qwen handling the language-heavy roles.

6. MiniMax M3: The Long-Document Multimodal Pick

Maker: MiniMax. Released: June 1, 2026. License: the MiniMax community license (custom terms, read before redistributing). Architecture: Mixture-of-experts, 428B total, 23B used per token. Context: 1 million tokens, with up to 512K tokens of output. Input: text, images and video, natively.

October 2026 standing: SWE-bench Pro 59.0% and SWE-bench Verified 80.5% on the MiniMax model card · not in the top ten of either public leaderboard in October.

MiniMax M3 was the June 2026 surprise. MiniMax used to be the "bulk processing" name on this list with its older abab models; M3 is a frontier-class release with a 1 million token window, native multimodal input, and an output budget of half a million tokens, second only to Kimi K3 on this list. If your workload mixes long documents, screenshots and recordings, M3 covers all three without a model swap.

It drops two places this month for two reasons. The autumn releases from Z.ai, DeepSeek, Xiaomi and Alibaba posted higher scores on the same coding benchmarks: Qwen 3.8 27B now reports 61.7 on SWE-bench Pro against M3's 59.0. And in the TSK-1 Benchmark, M3 was not scored, because 47.2% of its build actions failed while it reported the app as ready. That is a reliability flag for long agentic builds, not for document work, where M3 remains one of the best open options.

The 512K output budget is the underrated part. Most models stop long before they finish a full report, a translated manual or a long code file, so you have to stitch several calls together. M3 can write the whole thing in one response, which makes it a practical pick for document generation steps where the output, not the input, is the long part.

What it is great at

✓ Long-document analysis up to 1M tokens, with very long written output

✓ Native multimodal prompts (text, images and video in the same request)

✓ Replacing two-model pipelines (one vision model + one reasoning model) with one

✓ Medium-sized self-hosting: at 23B active, it is fast once loaded

Where it is not the best pick

• Long autonomous app builds (Kimi K3 and DeepSeek have stronger TSK-1 results)
• European-language content (Mistral Large 3)

Run it yourself

The weights need about 230 GB at 4-bit, so four 80 GB GPUs is a practical floor. Hosts include MiniMax's own API, CoreWeave, DeepInfra, Fireworks, Nebius and OpenRouter, listed on the MiniMax M3 page.

Inside Taskade Genesis

MiniMax M3 runs on Taskade credits on every paid plan; the model catalog calls it a fast open-source generalist in the Medium cost band, and MiniMax in Taskade covers the setup. On Business and up, a Together AI key also serves MiniMax M3 for custom agents and Ask Agent. Point document-heavy agents at M3 when the input mixes formats. A 500-page PDF with charts and screenshots is one M3 prompt, not a pipeline.

7. Google Gemma 4: The Best Local LLM Family

Maker: Google DeepMind. Released: April 2, 2026, with the 12B added in June and the technical report in July. License: Apache 2.0. Sizes: E2B (2.3B effective parameters), E4B (4.5B effective), 12B, a 26B-A4B mixture-of-experts (25.2B total, 3.8B active), and a 31B dense flagship. Context: 256K tokens on 12B, 26B and 31B; 128K on E2B and E4B. Input: text and images on every size, audio on E2B, E4B and 12B.

October 2026 standing: Google-reported scores for the 31B: MMLU Pro 85.2%, GPQA Diamond 84.3%, AIME 2026 89.2%, LiveCodeBench v6 80.0%, Codeforces rating 2150 · one of the strongest US-made model families you can run on a laptop.

Gemma 4 takes the slot that Microsoft Phi-4 held in earlier editions: the small, fast model you run on your own hardware. It wins that slot on range. One family covers a phone (E2B), a laptop (E4B and 12B), and a single workstation GPU (26B-A4B and 31B), all under Apache 2.0 with no usage cap. The 26B-A4B mixture-of-experts is the sweet spot for most people: it computes only 3.8B parameters per token, so it generates quickly even on modest hardware, while the 31B dense model gives the best quality per gigabyte.

Gemma 4 does not match the trillion-parameter models on hard agentic coding, and it should not be expected to. It is strong on math and reasoning for its size, and it reads images natively, which makes it a strong private assistant for documents that cannot leave your machine. Phi-4 (14B, MIT, December 2024, 16K context) is still a fine choice for a 16 GB machine and narrow formatting jobs, and gpt-oss-20b (Apache 2.0) is the other small model worth testing.

What it is great at

✓ Running fully offline on a laptop or a single GPU

✓ Private document and image questions where data cannot leave the device

✓ Fast local drafts, summaries and classification

✓ Fine-tuning on one GPU, under a license with no revenue gate

Where it is not the best pick

• Long agentic builds and hard multi-file coding (Kimi K3, DeepSeek, GLM-5.3)
• Million-token documents (Gemma 4 tops out at 256K)

Run it yourself

The 31B needs about 17 GB at 4-bit and the 26B-A4B about 15 GB, so both fit one 24 GB GPU or a 32 GB Mac. E4B and E2B run on 8 GB machines and phones. Ollama, LM Studio and llama.cpp all run Gemma 4, and the weights are on Hugging Face.

Inside Taskade Genesis

Gemma 4 is not in the Taskade model picker. Run it locally and connect an MCP-capable desktop client to the Taskade MCP Server: the local model does the thinking, and the server lets it read and write your Taskade projects. In automations, an OpenRouter provider step on your own key (Business and up) can call a hosted Gemma 4. See the best local LLMs section for the full hardware table.

8. Meta Llama 4 Scout: The 10-Million-Token Context Pick

Maker: Meta. Released: April 5, 2025. License: Llama 4 Community License (commercial use permitted under the 700M MAU cap). Architecture: Mixture-of-experts, 109B total, 17B used per token, 16 experts. Context: 10 million tokens, the longest window of any open model.

October 2026 standing: still the open context-length record holder · Meta's new open flagship, Muse Spark Open (released October 15, 2026; 816B total, 42B active, 1M context, Muse Model License), scores 39 on the Artificial Analysis open-weights index, the highest score of any US-made open model.

The Llama family is the most-forked open-source LLM line, and Llama 4 keeps the tradition: the largest ecosystem of fine-tunes, the broadest tool support, and well-documented function-calling behavior. Scout earns its place in October for one reason no newer model has taken away: a 10 million token window. That is enough to load a large codebase, a year of support tickets, or a full contract archive into one prompt.

Watch Muse Spark Open for the next edition. Meta released it five days before this update, with weights on Hugging Face under meta-models/Muse-Spark-Open-816B-A42B. Meta calls it natively multimodal, and Artificial Analysis lists it at 140 output tokens per second. It is the strongest answer yet to readers searching for the best non-Chinese open model. We have not run it through TSK-1, and its license is Meta's new Muse Model License rather than the Llama license, so read both before you switch. Until then, Scout stays here for long-context ingest, and Muse Spark Open is the Meta model to test for reasoning.

Scout also benefits from two years of Llama tooling. Most open-source serving engines, fine-tuning libraries and quantization tools supported Llama first, so a Scout deployment hits fewer rough edges than a model released last month. That is a real cost saving for a small team, even when a newer model scores higher.

What it is great at

✓ Whole-codebase and whole-archive ingest in one prompt (10M tokens)

✓ Tasks where a specialized community fine-tune already exists

✓ Tool calling with mature, well-documented behavior

✓ Workflows where predictability matters more than peak performance

Where it is not the best pick

• Pushing the open-source frontier on a single benchmark
• Hardest reasoning tasks (GLM-5.3, Kimi K3 and premium frontier lead)

Run it yourself

Scout needs about 60 GB at 4-bit, so it runs on one 80 GB GPU or a 96-128 GB Mac. Using the full 10M window needs far more memory for the context cache, so most self-hosted setups run a much shorter window. Muse Spark Open needs a multi-GPU node.

Inside Taskade Genesis

Llama models are not in the Taskade model picker. To use Scout's long window in a workflow, call it through an OpenRouter provider step on your own key (Business and up), then hand the extracted findings to an agent on Taskade credits. For long context on Taskade credits, GLM 5.3, Kimi K3, DeepSeek V4 Pro and MiniMax M3 all offer 1M-token windows.

9. Mistral Large 3: The European Flagship

Maker: Mistral AI. Released: December 2, 2025 (still the newest open-weight flagship). License: Apache 2.0 (full commercial use, no Research-vs-Commercial split; the older MRL/MNPL story is dead with Large 3). Architecture: Mixture-of-experts, 675B total, 41B used per token. Context: 256K tokens.

Benchmark snapshot (at launch): MMLU-Pro 73.11% · MATH-500 93.60% · Multilingual MMLU ~85.5% · LMSYS Arena Elo ~1418 (#2 open non-reasoning model at the time).

October 2026 update: Mistral released Mistral Large 4 as an API preview on October 6, 2026, at about 1 trillion total and 52 billion active parameters. Mistral says the weights will follow by the end of October, but none were published when we checked on October 20, so Large 3 keeps this slot until they ship and we can confirm the license.

Mistral became the European reference for open-weight models thanks to clear licensing, strong European language performance, and a focus on enterprise-ready releases. Mistral Large 3 is the cleanest commercial-use story of any European flagship: pure Apache 2.0, no MAU cap, no revenue gate. For teams that must keep a model vendor inside the EU legal framework, that combination still matters more than a few leaderboard points.

Large 3 or Large 4? Pick Large 3 when you need the weights today: it is the open, Apache 2.0 model you can audit, fine-tune and host in your own region. Pick Large 4 through Mistral's API when you want the newer model and can accept a hosted preview. When the Large 4 weights ship, check three things before you switch: the license name, the hardware (about 1T total parameters is roughly 500 GB at 4-bit, well beyond Large 3's footprint), and whether your host offers it in the EU. For many European teams the hosting region matters as much as the model, and Mistral's own platform makes that choice simple.

What it is great at

✓ French, German, Italian, Spanish, Portuguese content

✓ Compliance-sensitive workflows where European jurisdiction matters

✓ Mixed enterprise use where Apache 2.0 license clarity is non-negotiable

✓ Tool calling with clean structured outputs

Where it is not the best pick

• Asian languages (use Qwen)
• Pure cost optimization (DeepSeek V4.1 Flash and GLM-5.3-Flash are cheaper)
• Agentic coding workloads (Kimi K3 and DeepSeek lead)

Run it yourself

Large 3 needs about 340 GB at 4-bit, so an 8× H100 node is the practical floor. Mistral's own API and the major clouds host it.

Inside Taskade Genesis

Mistral models run in Taskade on your own key. On Business and up, save a Mistral key under AI Model Keys and pick Mistral Large, Medium or Small for custom agents and Ask Agent. An agent chat on your own key uses no Taskade credits. Set Mistral Large on any agent that speaks to European customers.

10. Cohere Command A+: The Retrieval and RAG Specialist

Maker: Cohere. Released: May 20, 2026. License: Apache 2.0, with BF16, FP8 and W4A4 weights on Hugging Face. Architecture: Mixture-of-experts, 218B total, 25B used per token. Context: 128K input tokens and up to 64K output tokens. Input: text, images and tool results.

Benchmark snapshot (Cohere-reported): 37 on the Artificial Analysis Intelligence Index · τ²-Bench Telecom up from 37% to 85% against Command A Reasoning · MMMU 75.1% · 48 languages, up from 23.

Cohere built its reputation on retrieval-augmented generation, and Command A+ is the first Cohere flagship you can use commercially from the weights. Its predecessors, Command R+ (2024) and Command A, published weights under CC-BY-NC 4.0, so commercial use ran only through Cohere's API or partners. Command A+ moved to Apache 2.0, which is why it replaces Command R+ on this list.

Cohere calls it an "open-source enterprise workhorse", and the design shows it: reasoning, agentic workflows, RAG, multilingual tasks and multimodal document processing in one model, with a minimum footprint of two H100s or one B200 at W4A4. It is not the strongest model here. It is the one built for the boring, high-value job of answering questions from your own documents in many languages.

How to use it for RAG. A grounded-answer setup has three parts, and the model is only one of them. First, split your documents into passages and index them so a search can find the right ones. Second, send the question plus the top passages to the model, and tell it to answer only from them. Third, ask it to name the passage behind each claim, so a person can check the answer. Command A+ is tuned for the second and third steps across 48 languages. The first step, the index, is where most RAG projects succeed or fail, whichever model you choose.

What it is great at

✓ Question answering grounded in your own knowledge base

✓ Customer support agents tied to a documentation index

✓ Multilingual document processing in 48 languages

✓ Internal knowledge bots under a clean Apache 2.0 license

Where it is not the best pick

• Open-ended creative writing
• Hard agentic coding (Kimi K3, DeepSeek, GLM-5.3)

Run it yourself

Cohere states a minimum of two H100s or one B200 for the W4A4 build, and says W4A4 adds about 47% more speed. Cohere's own API serves it too.

Inside Taskade Genesis

Command A+ is not in the Taskade model picker. The retrieval pattern it is built for works on any model in Taskade: give an agent your projects and documents as knowledge, and pair it with the Memory Layer for citable, traceable answers. If you self-host Command A+, an MCP-capable client can connect it to your workspace through the Taskade MCP Server.

Best Local LLMs: What Runs on Your Own Hardware

The best local LLM in October 2026 is Qwen 3.8 27B if you have one 24 GB GPU or a Mac with 32 GB of memory. Gemma 4 26B-A4B is the faster alternative on the same hardware, gpt-oss-20b and Phi-4 fit 16 GB, and Gemma 4 E4B runs on an 8 GB laptop. Everything in the top five needs a multi-GPU server.

A local model is the only way to keep every prompt on your own machine, and it costs nothing per token once you own the hardware. The trade-off is quality and speed: the best single-GPU models in October 2026 score about 10 points below the top open models on the Artificial Analysis index (Qwen 3.8 27B at 34 against 44-46 for the leaders), and your tokens per second depend on your memory bandwidth.

How to Run an Open-Source LLM Locally

Four steps take you from nothing to a working local model:

1. Pick a runner. Ollama is a command-line tool with a model library, LM Studio is a desktop app with a model browser, and llama.cpp is the low-level engine both build on.
2. Pick a model that fits. Take the 4-bit weight size from the table above and add about 20% for the context cache. If the total is more than your free memory, pick a smaller model.
3. Download and run it. In Ollama, one command pulls and starts a model. Copy the exact model tag from the Ollama library, because tags change between releases.
4. Connect it to your work. Ollama serves a local API on port 11434, which most chat apps and coding tools can call. An MCP-capable desktop client can also connect the local model to the Taskade MCP Server to read and write your projects.

# Example with Ollama: pull and chat with OpenAI's open 20B model
ollama run gpt-oss:20b
List what is installed and how much memory each model uses
ollama list
ollama ps

What Do Q4 and Q8 Mean?

The "Q" number is the bits stored per weight after quantization. An 8-bit build (Q8) is close to the original model and halves the memory of a 16-bit build. A 4-bit build (Q4) halves it again with a small quality loss on most tasks, which is why 4-bit is the default for local use. Below 4 bits the loss grows quickly, so use a smaller model at 4-bit before you use a bigger model at 2-bit. Some 2026 models ship natively in a 4-bit format (gpt-oss and Kimi K3 use MXFP4), so their published size is already the small one.

When one machine is not enough, serving moves from a desktop runner to engines such as vLLM, which split a model across many GPUs. This walkthrough covers that next step:

Best Non-Chinese Open-Weight LLMs (US and European)

Meta's Muse Spark Open is the highest-scoring non-Chinese open-weight model in October 2026 at 39 on the Artificial Analysis open-weights index. Google Gemma 4 is the best non-Chinese local model, NVIDIA's Nemotron family is the most efficient for agents, and Mistral Large 3 and Cohere Command A+ are the Apache 2.0 picks from Europe and Canada.

Some teams need a model from a US or European lab for procurement, compliance, or policy reasons. In October 2026 the top five open models on both public leaderboards come from Chinese labs, so this list is a real trade-off: you give up a few index points for a vendor that fits your rules. The weights run wherever you host them, so the origin of the lab says nothing about where your data goes. Your host decides that.

Two of these run inside Taskade today without a server. Nemotron 3 Super is in the Taskade picker on every paid plan, and Nemotron in Taskade covers it. Its one TSK-1 test in August produced a plan but no app, so its model page shows the score as open until a new test. gpt-oss-120b and gpt-oss-20b run on your own Groq key on Business and up, for custom agents and Ask Agent.

Also Worth Knowing: Open Models Just Outside the Top Ten

The open field is too crowded for ten slots. These six models came close, and each one is the right pick for a specific team:

Kimi K2.7 Code also runs on Taskade credits on Max and Enterprise (model page).

How to Run Open-Weight Models Inside Taskade

Taskade gives you three ways to use open-weight models without running a server: pick one in the model picker on Taskade credits, run one on your own provider key, or connect a model you already run to your workspace through the Taskade MCP Server. Each path has a different plan gate and a different bill.

Two rules keep the bill predictable. An agent chat on your own key uses no Taskade credits, and the daily AI request limit still applies. A built-in AI step in an automation runs on Auto or a TSK rung on Taskade credits, so an automation reaches an exact open-weight model only through a provider step. Taskade Genesis app building and Taskade EVE chat always run on Taskade credits. The key providers page shows which models each key serves, and the provider steps guide walks through the automation side.

Every open-weight release follows the same path before it reaches a picker, which is why a model you read about today can take weeks to appear in a product:

Mistral Large 4 sat at the API preview stage on October 20, with weights promised by the end of the month. GLM-5.3 published its weights later in the same month as its API launch, and Kimi K3 took 11 days.

▲ ■ ● Workspace DNA: Where Open-Source Earns Its Keep

Every open-source LLM choice lives inside the same three-layer Workspace DNA that makes Taskade Genesis a real product, not a model picker.

Projects remember. Agents learn. Automations move.

▲ Memory

Memory is the knowledge-graph foundation. Projects, documents, transcripts, customer records. Every relationship mapped. Every update linked. Open-source long-context models like Kimi and MiniMax M3 read from Memory at scale and write summaries back into the same graph.

■ Intelligence

Intelligence is where the agents live. Each one tuned for a role. Each one running on the frontier model you chose for its task. Set it per agent — open-source on the roles that carry the volume, premium on the ones that finish the work — or leave an agent unpinned and Auto handles the default.

● Execution

Execution is where the work ships. Triggers pull events in. Actions push data out. The 100+ bidirectional integrations wire your tools together. Send the bulk steps to agents on cheap open-weight models, and keep premium models for the final delivery.

Memory feeds Intelligence. Intelligence triggers Execution. Execution creates Memory. The loop closes itself. Open-source LLMs slot into every layer at once.

The Four-Tier Memory Pyramid

Open-source LLMs handle short-term reasoning. Taskade Genesis handles the rest of the memory layer so the same conversation a year from now still knows what you sold to whom.

The open-source LLM you pick handles the Working tier. Taskade Genesis handles the rest. That is the moat.

How to Choose: A Practical Decision Tree

In practice you do not pick once and stick with it. You pick per task. The strongest pattern across teams shipping in 2026 is a heavier model for the final answer and a lighter open-source model for everything that leads up to it.

Five Patterns That Work Right Now

Real workflow shapes that combine open-source and premium models inside Taskade Genesis. Steal them. Each one pins the model on an agent, because an agent is where Taskade lets you pick an exact model; an automation reaches that agent through an Ask Agent step, which uses the model set on the agent.

Pattern 1: Triage with DeepSeek, Answer with a Frontier Model

A support automation sends each incoming ticket to a triage agent pinned to DeepSeek V4 Pro, which sits in the Low cost band of the catalog. The interesting tickets route to a second agent on a frontier model for the actual response. The simple ones get a templated reply.

Pattern 2: Research with Kimi, Draft with MiniMax

A market research agent set to Kimi K3 reads a stack of long PDFs in a single 1M-token pass to extract themes. A second agent set to MiniMax M3 turns the structured themes into a long, publishable draft, using its 512K-token output budget. Both models run on Taskade credits: Kimi K3 on Max and Enterprise, MiniMax M3 on every paid plan.

Pattern 3: Code Review with DeepSeek, Ship with Taskade EVE

Point an MCP client that runs DeepSeek V4.1 Flash at the Taskade MCP Server. That model reviews the code and writes the edit, then calls Taskade's tools to inspect the app and save the files. The model choice lives in your client, not in Taskade. Taskade EVE orchestrates the rest of the build.

Pattern 4: Multilingual Customer Support

Give each language its own agent with its own model. European-language agents on Mistral Large through your own Mistral key (Business and up). Chinese and Japanese agents on GLM 5.3 or Kimi K3 (Max and Enterprise). English agent on DeepSeek V4 Pro. Same workspace. Same memory. Different brains.

  ┌──────────────────────────────────────────────────┐
  │  Customer message in 🇫🇷  →  Mistral Large        │
  │  Customer message in 🇨🇳  →  GLM-5.3              │
  │  Customer message in 🇩🇪  →  Mistral Large        │
  │  Customer message in 🇬🇧  →  DeepSeek V4 Pro      │
  │  Customer message in 🇯🇵  →  Kimi K3              │
  │  Customer message in 🇪🇸  →  Mistral Large        │
  │  ──────────────────────────────────────────────  │
  │  All routed through one inbox. One memory.       │
  │  One workspace. Different brains.                │
  └──────────────────────────────────────────────────┘

Pattern 5: Cost-Optimized Scheduled Automation

Any automation that runs on a schedule can leave its built-in AI steps on Auto, call an agent pinned to DeepSeek V4 Pro or MiniMax M3 for the bulk work, and reserve a frontier-model agent for the final actions that ship to customers. On Business and up, a Groq or OpenRouter provider step can also run an exact open-weight model on your own key.

What Open-Source LLMs Cannot Do Yet

Open-source is closing the gap but it has not closed it everywhere. On the LMArena text leaderboard of October 15, 2026, the top open model (Kimi K3, 1487) sits at rank 18 overall, 37 points below the top closed model.

The right framing is not "which is better." It is which mix is best for the work. Taskade Genesis lets you mix without committing.

Open Source vs Open Weight vs Restricted: A Quick Reference

A common source of confusion. Here is the practical answer.

For practical purposes, "open source" in marketing copy usually means open-weight. Check the specific license before redistributing fine-tunes or hosting them in a third-party product.

Pricing Inside Taskade Genesis

Open-weight models run on the same credit system as premium models in Taskade Genesis, usually in a lower cost band. The model catalog groups every model into a Low, Medium or High cost band, and the usage chip on each message shows the credits that turn used. Model credits explains the metering.

The Taskade pricing plans:

Bring your own key starts on Pro for OpenAI, Anthropic and Google Vertex AI keys. The keys that serve open-weight models (Together AI, Groq, Mistral) start on Business. An agent chat on your own key uses no Taskade credits, and the model call bills your provider account. Claude runs in Taskade on Pro and up, with your own API key (BYOK).

A Buyer's Note on Hype Cycles

A reminder for anyone reading this in six months.

• New frontier-class open-source models will appear. This list is the snapshot of October 2026, and it replaced three of the ten names from August. The shape of the list is more durable than the names.
• Benchmarks lie. Run the model on your own work. The numbers in the model card tell you what the lab tested. The numbers from your own prompts tell you what you actually get.
• Cost-to-quality moves. Today's premium model becomes tomorrow's mid-tier. Today's open-source champion becomes tomorrow's commodity. Build for the architecture (Memory → Intelligence → Execution) not for the specific model.

Taskade Genesis is built to absorb that drift. New models join the picker as Taskade adds them, and a pin on a retired model falls back to Auto. Your prompts keep working. And because every app you build is owned and versioned, the output stays accountable, not AI slop.

Frequently Asked Questions

What to Try This Week

Five small experiments. Each takes under 10 minutes inside Taskade Genesis.

1. ✓ Open Taskade Genesis and switch one agent to DeepSeek V4 Pro (every paid plan) or GLM 5.3 (Max and Enterprise). Run a normal task. Compare the output.
2. ✓ Add an Ask Agent step to one automation and point it at an agent on MiniMax M3. Note the credits on the usage chip.
3. ✓ If you code, connect your MCP client to the Taskade MCP Server and let the model you already run there edit a Taskade Genesis app.
4. ✓ Pull Qwen 3.8 27B or Gemma 4 in Ollama on your own machine and ask it the same question you gave the hosted model. Notice where a local model is already enough.
5. ✓ Try a long-document analysis on MiniMax M3 with a 500-page PDF (1M-token window). Notice retrieval is no longer the bottleneck.

Build an app with any of these models →

▲ ■ ● Final Word

Open-source AI LLMs in 2026 are not the future. They are the present.

Between April and July 2026, a run of flagship open-weight releases reset this ranking: DeepSeek V4 Pro (Apr 24, MIT, 1M context, SWE-bench Verified 80.6%), Kimi K2.6 (Apr 20, the first open model to lead every premium frontier model on SWE-bench Pro), Kimi K2.7 Code (June 12), GLM-5.2 (June 13, MIT weights, GPQA Diamond 91.2%), MiniMax M3 (June, SWE-bench Pro 59.0%), and Kimi K3 (July 16, weights July 27), which shipped 2.8 trillion open parameters with a 1M-token window. Then August to October went wider still: GLM-5.3, DeepSeek V4.1 Flash, MiMo-V2.6-Pro and Qwen 3.8 pushed the open-weights index to 46, and Meta Muse Spark Open gave US buyers a top-tier open option. The frontier moved while everyone was reading benchmark hot-takes.

The ten picks above ship real work today inside Taskade Genesis. Mix them. Use the heavier picks where they earn their cost. Use the lighter picks for everything in between. Let Workspace DNA handle the memory the model cannot.

Apps used to run your business. Now your business builds the apps. Projects remember. Agents learn. Automations move. One workspace. One memory. One credit system. Open-weight models and frontier models from top AI labs in the same picker. Pick the right model for every agent.

This is the origin of living software. 🌱

Cover photo: the CSIRO GPU cluster at the data center, by CSIRO, via Wikimedia Commons, licensed CC BY 3.0.

Related reading

• TSK-1 Benchmark. The benchmark that grades models on building complete, working apps, with dated evidence for every finding.
• Multi-Model AI Access. Pick the right model for every task in Taskade Genesis.
• Model Credits. How credits are metered and what each plan includes.
• Taskade model directory. Every model Taskade runs, with plan, context window and TSK-1 result.
• Key providers. Which models each of your own provider keys serves.
• AI builders with your own key. Platforms that accept your own provider API key.
• No-code builders for open-weight models. Run open models without hardware or code.
• Moonshot AI and Kimi history. How Moonshot reached a 2.8T open model.
• Open-source LLM history. From GPT-2 to Kimi K3.
• How to reduce LLM costs. Model routing and caching patterns that cut the bill.
• Kimi vs DeepSeek. The two open leaders side by side.
• Kimi vs Claude. An open model against a premium one.
• Tools for AI Agents. The built-in toolkit every agent can call — web search, code, file analysis, and more.
• Taskade MCP Server. Plug Claude Desktop, Cursor, and other MCP clients into your workspace.
• Multi-Agent Workspace: Memory, Agents, Workflows. The three-layer Workspace DNA in depth.
• Your Taskade Welcome Series. What lands in your inbox over your first week.
• Automatic User Provisioning with SCIM. Sync users from Okta or Azure AD.
• Custom AI Agents. Per-agent model selection and tool loadouts.
• Multi-Agent Teams. Specialized agents collaborating with different model picks.
• Top Open-Source Autonomous Agents. The agent-framework landscape that pairs with these models.
• Best AI Coding Tools 2026. Where open-source LLMs are reshaping the developer toolchain.
• History of Mermaid Diagrams as Code. The diagram engine powering every visual in this post.

Build an app with any of these models →