Which open model for which job

We have published a guide with 80 enterprise use cases and the open model that solves each one best.

This article explains how we built the guide: the criteria that assign a model to a case, why the best model in the rankings is almost never the one you should deploy or use, and how you can decide for yourself when the next one lands.

The gap with closed models

The market ceiling is exactly 63 points on the Artificial Analysis Intelligence Index. Claude Opus 5 has dominated it since 24 July 2026. Just below sit several closed models: Claude Fable 5 at 62, and GPT-5.6 Sol and Grok 4.6 at 61.

The best open model you can download, install and audit scores 60. There are actually two: Kimi K3 and GLM-5.3. Three points behind Opus 5, and a single point behind Grok 4.6 and GPT-5.6 Sol.

In months the distance reads better. The truth is that there has been no enormous leap in these last few months. Those 60 points are what GPT-5.5 scored when it led the index at 60.2 in April 2026, to give you an idea. The closed models have not moved that far, and the open ones have caught up with them.

*Artificial Analysis Intelligence Index and cost per index task, in dollars, read on 31 August 2026. Weights are the safetensors totals published on Hugging Face, which is what decides how many GPUs you need to serve the model.*

But let us get into costs, not just benchmarks.

Claude Fable 5 costs 3.14 dollars per index task, on a rate card of 10 dollars per million input tokens and 50 per million output.

GLM-5.3, two points below it, costs 0.90 per task and also downloads.

GPT-5.6 Terra scores 57 and costs 0.53 per task.

GLM-5.3-Flash scores the same 57, costs 0.10, weighs 328 GB and ships under MIT.

Two points of index cost 3.5 times as much per task, and five points cost thirty-one times as much.

And one figure of ours to close, from our open data : 99.5% of the tokens running through Helmcode go through open models, in real production.

The gap exists, briefly, at the frontier edge, and almost no real work lives there.

The three axes that decide which model to pick

Almost everyone picks a model by reading a table of scores. Plenty of models are built to break benchmarks rather than to do daily work. These are the three axes we use to recommend a model for each use case.

Axis 1. The quality your case needs, against cost per task

The 63 points of Opus 5 cost 2.34 dollars per task. The 57 of GLM-5.3-Flash cost 0.10.

What decides which model to use is whether your case can tell 57 from 63. Classifying a support ticket cannot, and it will do it forty thousand times a month. Analysing your market, five competitors, their prices, documentation and moves over the last year before deciding where to invest can tell the difference, and you might do it once a quarter.

That is how we recommend splitting the budget. The volume work goes to the model that is smart enough and cheap at the same time.

Axis 2. The real context of the work

What actually goes into each request, and how many times a day.

A forty-page contract a thousand times a month and an investigation that crosses hundreds of documents, reports and sources to prepare a strategic decision both look like "long documents", and they are opposite decisions: the first optimizes for cost per page, the second for the ability to reason across sources.

There is an expensive confusion here, and it has to do with the context window. What fits in the model is not the same as what the model reasons about and understands. There are 10 million token windows on models that do not reason. To know who genuinely understands a whole case file you have to look at a long-context reasoning evaluation, and there the best open model is Kimi K3 at 82.7% on AA-LCR.

Axis 3. The deployment constraint, which in open models is measured in compute

A closed model is paid per token and takes no space; an open one has to be held up. The practical unit is the eight-GPU node, because that is how they are bought:

• GLM-5.3-Flash, 57 points, 328 GB of weights: one node.
• GLM-5.3, 60 points, 755 GB: two nodes.
• Kimi K3, the same 60 points, 1.56 TB: about eight nodes.

Three points of index can cost twice or eight times more infrastructure depending on who you buy them from. This calculation tends to get forgotten once we have fallen in love with benchmark numbers.

The base: eleven models carry all 80 cases

Of the 80 cases in the guide, eleven models carry at least one, and with seven you already cover 95%. That concentration is good news, because it lets you reach most tasks with few models. Thinking one model does everything is a fantasy. Or a waste of money. What matters most is the judgement to know who to delegate to at each moment so that all the work is covered.

DeepSeek V4 Flash 0731, the workhorse (26 cases)

The release of DeepSeek V4 Flash 0731 was a milestone in what we at Helmcode call all-terrain models. They have plenty of capability and cost little, the way Opus 4.6 or Qwen 3.6 did in their day. 1M of context, 122 tokens per second and 0.11 dollars per task.

It does the most work in the guide because most of the work in a company is extracting, summarizing, retrieving and translating at volume.

Yes for: summaries, RAG, bulk translation, analysis over whole documents, turning emails into tasks.

No for: text a person signs and sends outside the company, and long multi-step agents.

Its bigger sibling, DeepSeek V4 Pro 0813 (53 on the index), keeps a single case, bounded code generation, because it is the only one with the figure that measures it published: 80.6% on SWE-bench Verified.

Qwen3.8-27B, it fits on one machine (23 cases)

It is the best open writer that fits on a single machine, and it is multimodal too: up to 16,384 visual tokens per image, which is what lets it read a scanned A4 with small print.

Yes for: sales proposals, policies, CV screening, scanned invoices, marketing content.

No for: long agentic runs, where it falls short of the GLMs.

GLM-5.3-Flash, the best reasoning (15 cases)

It took over every case GLM-5.2 was carrying in one go. It has been a big improvement in coding and reasoning. On agentic coding Z.ai publishes 84.3 on Terminal Bench 2.1 and 63.4 on DeepSWE.

Yes for: contracts, fraud, strategy, case law, autonomous coding agents.

No for: any case that does not need reasoning. The cases where a smaller model is the better fit.

Gemma 4 12B, it works in milliseconds (6 cases)

Google's own licence with use restrictions, 22 points on the index. It scores low and that does not matter, because in its job you supply the judgement yourself, written into the prompt.

Yes for: classifying and routing tickets, prioritizing the inbox, spotting urgency, flagging personal data, all on a modest GPU and fine-tunable on your own history.

No for: anything that needs reasoning.

From the same family, Gemma 4 26B does multimodal moderation at the cost of a mid-size model, with 280 visual tokens per image: plenty for a chart and far too few for a scanned payslip. We serve it on the flat rate.

Qwen3.8-Flash-Next, the multimodal ceiling (2 cases)

56 on the index, and with image and video in.

Yes for: quality inspection from photos or video, product image analysis. It is also an alternative for GLM-5.3 use cases, coding included.

Whisper large-v3-turbo, voice in (2 cases)

99 languages and no cap on recording length. It is the most downloaded open speech model there is and the cheapest to run. We serve its bigger sibling, large-v3, at twice the size.

Yes for: transcribing meetings and customer calls without the audio leaving your network.

For voice out there is Chatterbox Multilingual (MIT, 500M), which speaks 23 languages, Spanish among them, and clones a voice from a few seconds of reference. The obvious alternative, Kokoro, only speaks English.

qwen3-embedding and its reranker, the forgotten 50% (2 cases)

They are not an LLM and they decide more than the LLM does: in a system that answers questions over internal documentation, retrieval quality matters more than the model writing the answer.

Yes for: semantic search and result reranking. If your RAG answers badly, start looking here.

Kimi K3, frontier but heavy and expensive (1 case)

60 points on the index. We tested it and decided not to serve it: too heavy and too expensive for output that GLM-5.3 matches. K3 takes twice the disk and costs 2.30 dollars per task against 0.90. It is a very good model all the same.

And it is still our recommendation on one case, a due diligence with hundreds of documents, because there what matters is reasoning across thousands of documents and K3 leads the open field with that 82.7% on AA-LCR.

GLM-5.3, the open ceiling in text (0 cases)

60 on the index, level with K3 on half the disk, and the best published open agentic figures there are (88.2 on Terminal Bench 2.1 and 66.9 on DeepSWE, measured by its maker).

It carries no case in the guide for three concrete reasons: it does not read images, it costs seven times more per task than its Flash sibling, and it asks for two nodes instead of one.

We recommend it for agentic coding with a lot of context, same as Kimi K3. But GLM-5.3-Flash will do for 99% of cases.

Fifteen cases, with their model and their alternative

Fifteen out of eighty, covering the ten areas and the three complexity levels in the guide. Every one of them has its full card in the guide, with the reasoning and the deployment in detail, and the grid filters by area and by model.

The six categories of work the guide publishes

Models change, your work does not. Any enterprise case falls into one of six families, and each family has its own assignment logic.

1. Classification and extraction

You write the criteria, the rules and the context, so the model does not need to be clever: it needs to be fast, cheap and inside your network, because it will see every message that comes in. A small model fine-tuned on your own history beats any large model that has not been. Size up only when the input is a whole document or an image.

The signal: does the prompt fit on one page? Then use a small model.

2. Text generation

An internal email or a thousand ad variants tolerate the cheapest model in the catalogue. A sales proposal or a performance review is read by someone who judges the person who sent it, and there it pays to have the best writer you can afford.

The signal: does it leave the company with a signature on it?

3. Reasoning over long documents

The family where the enormous model earns its keep, and where you have to read the right evaluation. A million tokens of context on a model that does not reason reads a lot and concludes nothing. Careful, though: three annual runs do not pay for a cluster. For one-off jobs it may well be worth paying for the best model through an API.

The signal: is the value in one document, or in the relationship between thousands of them?

4. Code and agents

The real split goes by autonomy rather than by language: generating a bounded function or test, against an agent taking twenty steps with a terminal and tools. Different leaders measured by different benchmarks. That is why code generation and coding agents go to different models in the guide.

The signal: how many times does the model decide without you looking?

5. Multimodal

Here the visual token budget per image rules. 280 tokens read a chart. A payslip or a scanned A4 in six-point type needs 16,384. Two models with near-identical index scores fail in completely different ways on the same scan, so check how many input points the vision side has.

The signal: is the answer in small print, or blurred?

6. Voice

There is never one model here: two or three are chained, to transcribe, reason and answer with a voice. And what rules candidates out is the maximum length per call and the languages supported. The most accurate model in the open market stays out of our guide because it caps at 30 minutes and covers 8 languages, when the two most common jobs are meetings and customer calls. If your work does not need calls longer than 30 minutes, Mistral's Voxtral is European.

The signal: how long is the recording, and what language does your customer speak?

Start with one use case and compare both results

The cheap way to check all of this is to take one case from the guide, point the same code at another endpoint and read both outputs side by side. It will take you 20 minutes at most, and it lets you compare your current closed model against the recommended open one.

If you want the whole map, the 80 cases with their models are published, filterable by area and by model, and you can download the guide as a PDF.

And if you would rather we told you where to start with your specific case, talk to us .

*Figures from Artificial Analysis and Hugging Face, read on 31 August 2026.*

*Weight sizes are the safetensors totals published by Hugging Face, which is the number that decides how many GPUs you need.*

*The GLM agentic coding figures and the DeepSeek SWE-bench figures are published by their makers, so they count as guidance rather than independent measurement.*