There is a single question that decides which open-weight coding model you actually run, and it is almost never "which one scores highest." It's this: what is the smallest, cheapest box that runs this thing without turning deployment into a science project? For most of 2026 the honest answer for anything near frontier quality was a quantization project on an 80GB card, or a multi-GPU node, or a hosted API. Cohere's North Mini Code is the model that makes the answer "one H100, FP8, ship it."

North Mini Code 1.0 landed on June 9 under Apache 2.0 — Cohere's first developer model and the debut of its North family. It is a 30-billion-parameter sparse Mixture-of-Experts that activates just 3B parameters per token (128 experts, 8 fire per token, with sliding-window and global attention interleaved 3:1). On SWE-bench Verified it posts 67.6%, and it clocks 33.4 on the Artificial Analysis Coding Index. Those are frontier-adjacent numbers from a model a third the total size of Qwen3-Coder-Next and a twenty-fifth the size of GLM-5.2.

The benchmark spread is noise. The deployment spread is the story.#

Line the three credible single-GPU-or-cheaper open coders up by score and they're all in the same class:

A seven-point spread across different benchmark harnesses, on tasks with real run-to-run variance, is not what decides your architecture. If you swapped these three under a production agent for a week, the thing you'd notice is not the SWE-bench delta. It's the bill and the box.

All three are frontier-adjacent coders. Only one of them fits a single H100 at native precision with no quantization step. That's the number that changes what you ship.

Here's the box, which is where North separates:

ModelTotal / activeFits whereQuant to fit?
North Mini Code30B / 3B1× H100, FP8No — FP8 ships native
Qwen3-Coder-Next80B / 3B1× 80GB cardYes — ~48.8GB at Q4_K_M
GLM-5.2753B / 40B~8-GPU H200 nodeRent the hosted API

Qwen3-Coder-Next also fits one card, and we've made that exact case — but you get there by running a Q4_K_M GGUF at ~48.8GB, which means picking a quant, validating it didn't cost you accuracy, and living with the quirks of a quantized MoE. GLM-5.2 is a different weight class entirely; full precision is roughly an 8-GPU H200 node, so for most teams the real deployment is the hosted API at $1.40/M input. North's 30B total is small enough that Cohere just ships an FP8 checkpoint that runs on one H100, no quant tuning, and — the detail that matters for an agent — vLLM-native tool-call and reasoning parsing built in.

Running it: one command, one card#

The FP8 build is designed for vLLM and is not loadable through plain transformers (the quantization format is vLLM-specific). The serve command Cohere ships is a single line:

vllm serve CohereLabs/North-Mini-Code-1.0-fp8 \
  -tp 1 \
  --max-model-len 320000 \
  --tool-call-parser cohere_command4 \
  --reasoning-parser cohere_command4 \
  --enable-auto-tool-choice \
  --moe-backend triton

Note -tp 1: tensor parallelism of one — a single card. The --tool-call-parser and --reasoning-parser cohere_command4 flags are what make it drop straight into an agent loop; you get structured tool calls and interleaved reasoning without writing your own parser. If you're on a smaller card or the edge, Cohere also publishes a North-Mini-Code-1.0-w4a16 build that trims memory further with, per Cohere, negligible quality loss over BF16.

That's the whole setup. No node, no NVLink topology to reason about, no quant to bless.

Where North loses — and it does lose#

This is a decision piece, not a coronation. North Mini Code gives up real things:

The decision, in one line each#

All three are Apache/MIT open weights, so all three end the per-token bill the moment you self-host. The only real question left is how much machine that costs you — and North Mini Code just set the floor at one card.