Can North Mini Code run on a single GPU?

Cohere states a minimum of one H100 at FP8 or FP4. The model has 30B total parameters, so memory is the constraint, but only about 3B are active per token, which keeps per-token compute low.

Is North Mini Code licensed for commercial use?

Yes. The weights are released under Apache 2.0, which allows commercial use, modification and redistribution with attribution. That is different from Cohere's Command R7B, whose open weights are non-commercial.

Why does North Mini Code perform worse in my agent than the published scores?

Check that your client passes the model's thinking content and tool calls back into later turns, that you use the documented vLLM parsers, and that sampling is set to temperature 1.0 and top-p 0.95. Published scores also depend on the SWE-agent and ReAct harnesses Cohere used.

North Mini Code: Cohere's 3B-Active Agentic Coding Model

Cohere built its reputation on enterprise retrieval models, not coding agents. North Mini Code is a deliberate change of direction: Cohere calls it its first agentic coding model, and it is the first release in a new North family. It was announced on 9 June 2026.

The interesting thing about it is not a headline score. It is the size. North Mini Code activates about 3B parameters per token, which puts it in the class of models people run on one GPU, and Cohere is pitching it on speed as much as on quality. That changes how you should evaluate it.

The spec sheet in one place

Architecture: mixture-of-experts, 30B total parameters, about 3B active per token.
Context: 256K tokens, with up to 64K tokens of generation.
Licence: Apache 2.0. Cohere's launch post lists bf16, fp8 and w4a16 builds on Hugging Face.
Minimum hardware: Cohere's launch post states one H100 at FP8, or one H100 at FP4.
Modalities: text in, text out, per the OpenRouter listing.
Intended work: code generation, agentic software engineering and terminal tasks.
API id: north-mini-code-1-0 on Cohere's own API.

Apache 2.0 is the part a product team should notice first. It permits commercial use, modification and redistribution with attribution, which is a much simpler position than Cohere's older open releases. Command R7B, for comparison, ships its weights under a non-commercial licence.

If the gap between 30B total and 3B active is unfamiliar, active vs total parameters explains why memory follows the first number and per-token compute follows the second.

Reading the benchmark numbers

The Hugging Face model card reports three agentic coding scores:

SWE-Bench Verified — 67.6
SWE-Bench Pro — 40.2
Terminal-Bench v2 — 36

Cohere's announcement adds a score of 33.4 on the Artificial Analysis Coding Index, which it describes as competitive among similarly sized models.

The method matters as much as the numbers. The SWE-Bench runs used the SWE-agent harness, version 1.1.0. Terminal-Bench v2 used a deliberately simple ReAct harness with a single terminal tool. Each benchmark was run with three seeds and averaged, which is better practice than a single best run. Cohere also notes that some competitor scores were run internally rather than taken from public reports.

Read the 67.6 as a score for the model inside that harness, not as a property of the weights. A different agent scaffold, a different tool format or a lower reasoning budget can move it by several points either way. Vendor-claimed vs independent benchmarks covers how to discount numbers like these without dismissing them.

Speed is the real pitch

Cohere's launch post leans on throughput. Against Devstral Small 2 on identical hardware and concurrency, it reports up to 2.8 times higher output throughput and roughly 30 percent better inter-token latency. Time to first token was closer, with Devstral Small 2 slightly ahead.

That combination matters for agents in a specific way. A coding loop is many short turns: read a file, run a test, read the failure, edit. Each turn pays time to first token once and then streams a modest amount of output. A model that streams fast but starts slightly slower will feel quick on long edits and only average on rapid back-and-forth tool calls. Measure both on your workload before assuming the throughput figure translates into wall-clock time saved.

Running it without breaking it

The model card has three practical requirements that are easy to miss:

Keep the thinking. North Mini Code supports interleaved thinking and Cohere says it works best enabled. The card asks you to pass the model's thinking content and tool calls back into later steps. Many clients strip reasoning from the history to save tokens; with this model that is likely to hurt multi-step performance.
Use the right parsers. On vLLM, the card points to the cohere_command4 reasoning and tool-call parsers and a recent cohere_melody package for response parsing. A mismatched parser shows up as tool calls leaking into plain text.
Use the recommended sampling. Temperature 1.0 and top-p 0.95. Turning temperature down to zero out of habit is not the documented setting.

Cohere says the model was trained to work with OpenCode and most other coding agents, and the card includes an OpenCode configuration for a local vLLM server. The opencode setup guide covers pointing that tool at a custom endpoint.

The free endpoint and what it is for

The catalogue variant is cohere/north-mini-code:free on OpenRouter, listed at zero cost for input and output at the time of writing. A free router endpoint usually comes with tight rate limits and is intended for trying a model out. Cohere's launch post lists it as free on Hugging Face and OpenRouter, and its model documentation points production deployments to Model Vault, its dedicated managed inference service.

Free tiers are good for exactly one thing: finding out whether a model is worth paying for. Do not build an agent fleet on one. Limits change without much notice, and a rate-limited agent fails in confusing ways mid-task. If you need predictable capacity, self-host the Apache 2.0 weights or pay for dedicated serving.

Where it fits

The natural home for North Mini Code is a team that wants a coding agent it can run on its own hardware: air-gapped environments, code that cannot leave the building, or high-volume background jobs where per-token API costs add up. One H100 is a realistic deployment target, and which open model fits your GPU goes through the memory arithmetic.

It is not a frontier model. On long, ambiguous tasks that need deep planning, a much larger model will usually finish more often. Within Cohere's own line, the choice is simple: North Mini Code for anything that edits code or drives a terminal, Command R7B for cheap grounded answers over retrieved documents.

A test plan worth an afternoon

Pick ten closed issues from your own repository, each fixed in under a day by a person.
Run them through your real agent harness with thinking enabled and preserved across turns.
Record pass rate, number of turns and total wall-clock time per task, not just pass or fail.
Run the same ten with the model you use today and compare cost per solved task.

If a 3B-active model solves seven of the ten that your current model solves, at a fraction of the serving cost, it has earned a place as your default worker, with the bigger model kept as a fallback for the rest.