Meet ‘North Mini Code’: Cohere’s 30B Open-Weight Mixture-of-Experts Model With 3B Active Parameters for Agentic Coding

For makers and artists building software, the landscape is shifting towards sovereign AI: running capable models on your own terms without relying on massive cloud clusters. Cohere has responded with North Mini Code, its first developer-facing coding model. It is an open-weight mixture-of-experts (MoE) system with 30 billion total parameters, yet only 3 billion activate per token. This efficiency allows teams to self-host capable coding agents with minimal hardware.

North Mini Code

North Mini Code is a 30B-A3B parameter model. The A3B designation signifies three billion active parameters per forward pass. Cohere has optimised the model for three specific jobs: code generation, agentic software engineering, and terminal tasks. It functions as a text-in, text-out system, lacking any capability for image or video input.

The model supports a 256K token context window, with a maximum output length of 64K tokens. Cohere lists a minimum hardware requirement of one H100 running at FP8 precision. Weights are available under the Apache 2.0 license on Hugging Face, though the associated card includes a non-commercial note. Access is also available via the Cohere API, Model Vault, and OpenRouter.

The Architecture

North Mini Code is a decoder-only Transformer featuring sparse MoE layers. Its attention mechanism interleaves two types of attention in a 3:1 ratio. Sliding-window attention employs RoPE for positional encoding, whereas global attention uses no positional embeddings at all. The feed-forward block contains 128 experts, with eight activating per token. Each expert is a feed-forward network (FFN) utilising SwiGLU activation.

The router applies a sigmoid function before top-k selection. A single dense layer sits before the sparse layers, a design choice that keeps active compute low while widening total capacity. Cohere released the weights in BF16 format.

Post-training occurred in two phases. First came two-stage cascaded supervised fine-tuning (SFT). This was followed by reinforcement learning with verifiable rewards (RLVR). The post-training focus was strictly on agentic coding. The model supports interleaved thinking and native tool use.

Benchmarks

Cohere reports a score of 33.4 on the Artificial Analysis Coding Index, describing this as a competitive position among similarly sized models. The evaluation covered SWE-Bench Verified, SWE-Bench Pro, and Terminal-Bench v2. Additional tests included Terminal-Bench Hard, SciCode, and LiveCodeBench v6.

The methodology was specific. SWE-Bench used the SWE-agent harness v1.1.0. Terminal-Bench v2 utilised a simple ReAct harness with one terminal tool. Terminal-Bench Hard used the Terminus-2 harness. Each benchmark ran with three seeds before averaging. Sampling parameters were temperature 1.0 and top_p 0.95.

The Speed

In Cohere’s internal tests, North Mini Code achieved up to 2.8x higher output throughput compared to Devstral Small 2, holding concurrency and hardware identical. It also demonstrated a 30% edge in inter-token latency, with time-to-first-token remaining closer between the two models.

Use Cases With Examples

Cohere built North Mini Code specifically for agentic workflows. Three patterns stand out in its own framing:

• Sub-agent orchestration: A main agent delegates subtasks to helpers. For example, one agent writes unit tests while another fixes failing code.
• Systems architecture mapping: The model reads a repository and sketches its structure. An example is tracing how services call each other before a large refactor.
• Code reviews: The model scans a diff for problems. An example includes flagging an unguarded null dereference before a merge.

Terminal tasks fit the model well as well. An example involves listing files, running a build, and then parsing the output for errors.

Getting Started

The fastest path to deployment is via Hugging Face Transformers. You must install Transformers from source for this model. Recommended sampling settings are temperature 1.0 and top_p 0.95.

# Install Transformers from source (required for this model):
# pip install "git+https://github.com/huggingface/transformers.git"
from transformers import AutoTokenizer, AutoModelForCausalLM

model_id = "CohereLabs/North-Mini-Code-1.0"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto")

prompt = "Write a python program to check if a string is a palindrome or not."
messages = [{"role": "user", "content": prompt}]

# return_dict=True yields a dict (input_ids + attention_mask) so **inputs unpacks cleanly
inputs = tokenizer.apply_chat_template(
    messages,
    tokenize=True,
    add_generation_prompt=True,
    return_dict=True,
    return_tensors="pt",
).to(model.device)

gen_tokens = model.generate(
    **inputs,
    max_new_tokens=1024,
    do_sample=True,
    temperature=1.0,
    top_p=0.95,
)

# Decode only the newly generated tokens, not the prompt
output = tokenizer.decode(gen_tokens[0][inputs["input_ids"].shape[-1]:])
print(output)

For serving, vLLM works, provided you have vLLM main plus Cohere’s melody library installed. Accurate response parsing depends on the latter.

uv pip install "git+https://github.com/vllm-project/vllm.git"
uv pip install "cohere_melody>=0.9.0"

vllm serve CohereLabs/North-Mini-Code-1.0 \
  -tp 2 \
  --max-model-len 320000 \
  --tool-call-parser cohere_command4 \
  --reasoning-parser cohere_command4 \
  --enable-auto-tool-choice

Quantised builds exist for Ollama, LM Studio, and llama.cpp. You can also try the model before downloading. Cohere offers free access through OpenCode and a hosted Hugging Face Space.

Key takeaways

• Cohere’s first coding model, North Mini Code, is a 30B mixture-of-experts that activates just 3B parameters per token.
• It runs on a single H100 at FP8, with a 256K context window and 64K max output.
• Weights ship under Apache 2.0, though the Hugging Face card adds a non-commercial note.
• Cohere official release reports a score of 33.4 on the Artificial Analysis Coding Index, and up to 2.8x throughput over Devstral Small 2.
• Built for agentic coding-sub-agent orchestration, architecture mapping, and code reviews with native tool use.