Cohere North Mini Code: An Open 30B Agentic Coding Model

Cohere North Mini Code is the company’s first open-source coding model — a 30-billion-parameter mixture-of-experts released on June 9, 2026 that activates only about 3 billion parameters per token, fits on a single H100, and carries a fully permissive Apache 2.0 license. It is the first model in a new “North” family aimed squarely at developers rather than the enterprise buyers Cohere has historically served.

The headline is that a model this small posts a 33.4 on the Artificial Analysis Coding Index — an independent, third-party score — ahead of open models several times its size, including a 120B and a 123B competitor. The catch, and the part most coverage mentions in a single sentence before moving on, is that the same independent lab measured it generating roughly three times the output tokens of comparable models. That verbosity is a real, compounding cost in any high-volume pipeline, and it does not show up in a leaderboard ranking.

This guide covers what actually launched, how the architecture earns its single-H100 economics, where the model genuinely leads and where it does not, why the two Artificial Analysis leaderboards are not the same thing, and a recomputed cost model for the self-hosted versus managed decision that the verbosity number quietly changes.

On June 9, 2026, Cohere released North Mini Code 1.0 — described in its own materials as the first model in a new “North” family and built specifically for agentic software engineering. It is a meaningful departure: Cohere’s prior models, Command R and Aya, were not coding-focused, and the company has not previously shipped an open-weight coding model. With this release, Cohere becomes the first major enterprise AI vendor to put an open-source coding model on the table.

The model ships under an Apache 2.0 license — full commercial permissibility, including fine-tuning, redistribution, and commercial deployment. Weights are on Hugging Face in both BF16 and an FP8-quantized variant, and the model is also reachable through the Cohere API, Cohere Model Vault, OpenRouter, and OpenCode for teams that want to test without standing up their own hardware.

Cohere’s direct comparison model is Mistral’s Devstral Small 2, a 24B dense model. The framing matters: North Mini Code activates only ~3B parameters per inference step against Devstral’s full 24B of dense compute, which is the whole basis of Cohere’s efficiency pitch. It also lands in the same week as a wave of open-source coding releases — including Kimi K2.7-Code from Moonshot AI and GLM-5.2 from Z.ai — so readers sizing up the open field have several alternatives to weigh at once.

North Mini Code is a decoder-only Transformer with a sparse mixture-of-experts feed-forward design: 128 experts total, 8 activated per token through a sigmoid router. The result is 30 billion parameters of capacity but only about 3 billion active per token — so the inference compute is comparable to a ~3B dense model, which is what lets it run on a single H100 at FP8 precision (and at roughly 20 GB of RAM on Apple silicon via MLX). The context window is 256K tokens, large enough to hold a mid-sized multi-file codebase in a single pass, with a 64K maximum generation length.

The attention stack is a hybrid: an interleaved 3:1 ratio of sliding-window attention (with RoPE) and global attention (with no positional embeddings), following the “RoPE to NoPE” hybrid-attention approach, with a single dense layer ahead of the sparse layers and SwiGLU activations in the feed-forward blocks. Post-training is two-stage supervised fine-tuning followed by reinforcement learning with verifiable rewards (RLVR), using a CISPO algorithm against binary rewards from unit-test verifiers across more than 70,000 verifiable tasks in roughly 5,000 repositories, deduplicated against SWE-Bench.

One detail in the training story is worth pulling out because it explains the model’s headline strength. Cohere trained against three distinct agent scaffolds — SWE-Agent (a rich CLI), mini-SWE-Agent (a single bash tool), and OpenCode (individually typed tools returning structured JSON). Adding only about 6% cross-harness data to the SFT mix produced a ~10 percentage-point gain on the OpenCode evaluation while holding SWE-Agent performance steady. The design goal, in Cohere’s words from its documentation, is that performance should generalize across agent scaffolds rather than be tuned to a single one — which is exactly what you want from a model meant to slot into whatever harness your team already runs.

The agentic-coding benchmark profile is genuinely strong for the size class. On SWE-Bench Verified, the released model resolves 67.6% of tasks at pass@1 using the SWE-Agent harness. It posts 40.2% on SWE-Bench Pro, 36% on Terminal-Bench v2 at pass@1 with the Terminus-2 harness, and 61.0% on the mini-SWE-Agent benchmark — the last of which Cohere notes “emerged for free” from multi-harness training rather than being directly optimized. The chart below maps those scores; the SWE-Bench Verified bar is the one to anchor on.

The reason the size-to-score ratio looks so good is the independent verdict from Artificial Analysis: a Coding Index of 33.4, ahead of Qwen3.5 (35B-A3B), Gemma 4 (26B-A4B), and the direct competitor Devstral Small 2 (24B dense) — and, more surprisingly, ahead of substantially larger open models including Nemotron 3 Super (120B-A12B), Mistral Small 4 (119B-A6B), and Devstral 2 (123B). On output speed, Artificial Analysis measured roughly 210 tokens per second (8th of 127 open-weight models it tracks) with a 0.25-second time to first token against a class median of 1.95 seconds. The matrix below puts the comparison in one place.

No existing source we found combines hardware, license, and verbosity in one table alongside the Coding Index — most comparisons stop at two or three benchmark columns and quietly drop the cost dimensions that decide a self-hosting question. The Coding Index scores for the comparison models are reported by Artificial Analysis as below North Mini Code’s 33.4; where we did not have an exact published figure for a cell, we have marked it rather than guess. That honesty matters more here than table density.

This is the single most common source of confusion in the coverage, and getting it wrong will mislead a buyer. Artificial Analysis publishes more than one score, and they measure different things. The 33.4 figure is the Coding Index — a weighted average of Terminal-Bench Hard (agentic terminal tasks) and SciCode (scientific code generation). That is distinct from the broader Intelligence Index, where North Mini Code scores 27.6 (above gpt-oss-20B at 24.5, just below Mistral Small 4 at 27.8, ranking 18th of 127 comparable open-weight models). And both are distinct again from the Agentic Index, where it scores only 21.7.

The Agentic Index number is the honest counterweight to the headline. North Mini Code underperforms on non-coding agentic tasks — the τ²-Bench Telecom component, weighted at 37% of that index, drags the score down. The takeaway is precise: this is a strong, narrow coding model, not a general-purpose agent. The Coding Agent Index (built on DeepSWE, Terminal-Bench v2, and SWE-Atlas-QnA) is yet another separate leaderboard. If you see a single “score” quoted without naming which index it is, treat it as unverified.

Here is the part that almost every write-up mentions once and then drops. To complete the Intelligence Index evaluation, Artificial Analysis measured North Mini Code generating 75 million output tokens against a class median of 25 million — roughly three times the output volume of comparable models. This is independently reported, not vendor-stated. A leaderboard ranking treats those extra tokens as free; a production pipeline does not.

Verbosity compounds in two directions at once. Every extra output token is more inference cost and more latency, and in a high-volume agentic pipeline those two effects multiply. On a managed API where you pay per token, 3× the output is 3× the bill for the same task. On self-hosted hardware the dollar cost is fixed, but the verbosity shows up instead as GPU utilization and queue depth — you process fewer tasks per hour on the same H100. Either way, the 33.4 Coding Index does not tell you about it.

None of this makes North Mini Code a bad model — its speed (~210 tokens per second) partly offsets the latency penalty, and on fixed self-hosted hardware the marginal cost of extra tokens is zero in dollar terms. But it does mean the right way to evaluate this model is on your own workload, measuring total tokens emitted per completed task, not on its leaderboard position. The next section turns the verbosity number into the cost decision it actually drives.

VentureBeat framed the launch around a real architectural decision: a frontier managed model such as Claude Fable 5 is priced at $50 per million output tokens, while North Mini Code runs on a single H100 you control. To make that tradeoff concrete, the table below models a team running 1,000 agentic coding tasks per day. Two inputs are sourced — the $50/M managed rate and the ~3× verbosity ratio — and two are illustrative or estimated and flagged as such: a 4,000-token class-median output per task, and an H100 lease at roughly $2.50/hour. Recompute every cell from the formula in its note before relying on it for your own numbers.

The math is deliberately simple so you can audit it. At 1,000 tasks per day and a modeled 4,000 median output tokens each, a class-median model emits 120 million output tokens a month, which at $50/M is about $6,000. North Mini Code’s ~3× verbosity pushes the same workload to 360 million tokens — about $18,000 a month if it were billed at that managed rate. Self-hosted on a single H100 at an estimated $2.50/hour, the cost is fixed at roughly $1,800 a month no matter how many tokens the model emits. That is the real shape of the decision: the verbosity that would triple a per-token bill is irrelevant on fixed hardware, which is precisely why the open-weight economics can win for high-volume teams — provided you can keep the H100 busy.

Two honest caveats keep this from being a slam dunk. The per-task token figure is a placeholder — your real number depends on your tasks, and you should measure it before trusting the totals. And a single H100 has finite throughput, so the self-hosted column assumes the box can clear 1,000 tasks a day given the verbosity; if it cannot, you are buying more hardware and the fixed cost rises. This is exactly the kind of comparative, workload-grounded eval our AI and digital transformation engagements start with.

Cohere explicitly trained North Mini Code to work as a sub-agent under an orchestrator, and that points at a production architecture most coverage skipped. In a multi-agent coding pipeline, a frontier managed model handles orchestration — planning, decomposition, judgment — while North Mini Code handles the high-volume code execution underneath it on a single H100 you own. You get frontier-grade orchestration on the few expensive calls that need it, and fixed-cost code execution on the many cheap ones that do not. That hybrid is the practical answer for teams that cannot run a $50/M output model at the volume their agents generate.

The matrix below maps where North Mini Code fits — and, just as importantly, where it does not. Its Agentic Index of 21.7 is the guardrail: do not reach for it as a general-purpose agent for non-coding workflows.

If your team is building this kind of pipeline, the orchestrator is usually an open-source coding assistant, and North Mini Code as a local model would plug into a tool like Continue.dev. For the broader build-versus-buy framing on running models inside your own perimeter, our guide to self-hosting open-source AI models covers the deployment economics in full.

Four surfaces are live. Open weights on Hugging Face (BF16 and an FP8-quantized variant) for self-hosting and fine-tuning; the Cohere API and Cohere Model Vault for managed inference; OpenRouter for routed access; and OpenCode for using it directly inside an agentic coding workflow. The Cohere-stated efficiency claims below are the vendor’s own internal tests — useful as a directional signal, but treat them as such until independently verified.

Step back from the spec sheet and the release reads as a strategic signal. Cohere built its business on enterprise sovereign AI — banks, governments, healthcare — anchored on data-residency guarantees, with Command R and Aya as its flagship models. North Mini Code is the first model aimed at developers rather than enterprise procurement, and the new “North” family name marks a deliberate new product line. The sovereign-AI proposition now extends to developer teams: run a capable coding model entirely inside your own perimeter, under a permissive license, on hardware you control.

Read forward, this looks like Cohere trying to build developer ecosystem gravity the way Mistral did with Devstral — before the open-source coding race gets away from it. The same week brought Kimi K2.7-Code and GLM-5.2, and the field is crowding fast. An Apache 2.0 model that wins its weight class on an independent coding index, runs on one H100, and is explicitly built to act as a sub-agent is a credible opening move. The open question is whether Cohere sustains a release cadence and tooling story strong enough to keep developers once the novelty of the first “North” model fades.