Cohere's North Mini Code Beats 120B Models With Just 3B Active Parameters
Cohere's North Mini Code is a 30B MoE coding agent that fits on one H100, runs free under Apache 2.0, and beats models four times its size on coding benchmarks.
Takeaways
- New open-source coding agent: Cohere released North Mini Code, a 30B MoE model (3B active params) under Apache 2.0, free to use and self-host.
- Runs on a single H100: Fits on one NVIDIA H100 at FP8 quantization, making on-prem agentic coding viable for teams with data sovereignty requirements.
- Beats models 4x its size on coding: Scores 33.4 on the Artificial Analysis Coding Index, outperforming 120B+ models like Nemotron 3 Super and Devstral 2.
- 210 tokens/sec, 0.25s TTFT: Ranked 8th of 127 comparable open-weight models on speed; 2.8x higher throughput than Devstral Small 2.
- Verbosity is the main tradeoff: Generates 3x more output tokens than comparable models (75M vs. 25M median), which compounds cost in high-volume pipelines.
- Trained with RLVR on 70k+ real repos: Post-training used reinforcement learning with unit-test-verified rewards across ~5,000 unique repositories, not just static datasets.
Cohere just made a move that enterprise AI vendors rarely do: they shipped a genuinely useful open-source model aimed squarely at developers, not their usual enterprise buyers. North Mini Code is a 30-billion-parameter Mixture-of-Experts (MoE) coding model with only 3 billion parameters active at any given time, released under the Apache 2.0 license with no usage restrictions.
North Mini Code is the first model in Cohere's new family of models, specifically designed and trained for agentic software engineering tasks. Cohere's prior models, Command R and Aya, were not coding-focused, and the company had not previously shipped an open-weight coding model. This is a meaningful pivot.
One H100. Free. No strings.
North Mini Code landed with a straightforward pitch: a 30 billion parameter agentic coding agent, Apache 2.0 licensed, that fits on a single NVIDIA H100. MoE (Mixture-of-Experts) is an architecture where the model is split into many specialized sub-networks called "experts," and only a small subset of them activate for each token. North Mini Code routes each query to a small subset of specialized expert networks within the larger model, keeping inference costs dramatically lower than a dense 30B model would require.
The model ships under an Apache 2.0 license, with 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. Pricing on Cohere's API is currently $0.00 per million tokens for both input and output.
What it can actually do
North Mini Code is optimized for complex software engineering workflows, terminal-based agentic tasks, and high-quality code generation. On the Artificial Analysis Coding Index, it scores 33.4, which puts it ahead of models several times its size. Specifically, it outperforms Nemotron 3 Super (120B), Mistral Small 4 (119B), and Devstral 2 (123B) on coding tasks, despite having a fraction of their active parameters.
Speed is a genuine differentiator. Independent testing by Artificial Analysis ranks it 8th of 127 comparable open-weight models on output speed at 210 tokens per second, with a time to first token of 0.25 seconds against a class median of 1.95 seconds. In Cohere's own head-to-head testing, North Mini Code achieves up to 2.8x higher output throughput than Devstral Small 2.
Here is what the model is built to handle:
- Agentic software engineering: resolving real GitHub issues end-to-end (SWE-Bench style tasks)
- Terminal-based tasks: running shell commands, navigating filesystems, executing scripts
- Complex code generation: scientific programming, algorithmic reasoning (SciCode, LiveCodeBench)
- Sub-agent orchestration: understanding and directing other agents in multi-step pipelines
- Code review and architecture mapping across large codebases
The catch you need to know about
The model generated 75 million output tokens in Artificial Analysis benchmarking against a class median of 25 million. That's three times the output of comparable models. This verbosity is a real cost in production. If you're running high-volume agentic pipelines, North Mini Code will burn through significantly more tokens per task than its peers, even if the end result is correct. At zero cost on Cohere's API right now that's fine, but factor it in if you're self-hosting.
The model also underperforms on non-coding agentic tasks. It scores 14% on GDPval-AA (a benchmark for general real-world work tasks) and 37% on τ²-Bench Telecom (tool use in enterprise workflows). This is a coding specialist, not a general agent.
How it was built
The training pipeline is worth understanding because it explains why the model behaves differently from typical fine-tuned coding models. The architecture is a decoder-only Transformer-based sparse MoE model using interleaved sliding-window self-attention and full self-attention, with 128 experts of which 8 are activated per token.
Post-training used a two-stage approach. The first stage of supervised fine-tuning (SFT) used a broad data mix where code datasets made up 70% of trainable tokens. The second stage narrowed to 4.5 billion tokens of only agentic and reasoning-driven samples, with all tool calls verified as executable and correct. Critically, the team used over 70,000 verifiable tasks across roughly 5,000 unique repositories, deduplicating against SWE-Bench sources to avoid data leakage during evaluation.
After SFT, the model went through Reinforcement Learning with Verifiable Rewards (RLVR), a technique where the model gets a reward signal only when its code output passes actual unit tests, not a learned reward model. This is what separates it from standard instruction-tuned code models. RLVR training improved the final model from the SFT initialization by 7.9% absolute pass@1 on Terminal-Bench v2 and 3.0% absolute on SWE-Bench. The RLVR model also produced shorter trajectories and fewer invalid tool calls than the SFT-only checkpoint.
One particularly clever training decision: the team trained across multiple agent harnesses (SWE-Agent, mini-SWE-agent, OpenCode) rather than optimizing for a single scaffold. Adding just 6% harness-diversity data to the second SFT stage yielded a 10% gain on OpenCode evaluation while maintaining SWE-Agent performance, suggesting these skills transfer cheaply.
Why this matters beyond the benchmarks
For teams handling proprietary codebases or operating in regulated environments, a self-hosted MoE model on a single H100 that outperforms 120B+ open-weight models is a concrete architectural option. Data sovereignty for agentic coding pipelines now has a benchmark-backed answer that didn't exist before.
The broader signal here is architectural. The fact that 3B active parameters can outperform 120B dense models on coding tasks challenges the assumption that bigger always means better. MoE specialization, combined with RLVR on verifiable coding tasks, appears to be a more efficient path to coding capability than simply scaling up parameter counts. North Mini Code is the first model in a new "North" family aimed squarely at developers rather than the enterprise buyers Cohere has historically served, which suggests this is the beginning of a product line, not a one-off release.
Getting started
The quickest way to try it is through Hugging Face (weights available in BF16 and FP8) or directly via the Cohere API with a free API key. For a managed deployment, Cohere's Model Vault handles the infrastructure. If you want to drop it into an existing coding agent setup, it has been specifically trained for compatibility with OpenCode, but it works across most harnesses.
# Install the Cohere SDK
pip install cohere
import cohere
client = cohere.ClientV2(api_key="YOUR_API_KEY")
response = client.chat(
model="north-mini-code-1.0",
messages=[
{"role": "user", "content": "Refactor this Python function to use async/await: def fetch_data(url): ..."}
]
)
print(response.message.content[0].text)
The model runs at minimum on a single H100 at FP8 quantization. The Artificial Analysis benchmark page has the full independent evaluation breakdown if you want to dig into specific task performance before committing to a deployment.