North Mini Code

North Mini Code is an open-weight large language model developed by Cohere for agentic software development and AI code generation. Released on June 9, 2026, it is a sparse mixture-of-experts model with 30 billion total parameters and about 3 billion parameters active for each token. Its public model identifier is north-mini-code-1-0. Cohere describes it as the first model in the North code-agent family.^[1][2][3]

The model has a 256,000-token context window and can generate at most 64,000 tokens. It accepts text and produces text or structured tool calls. Cohere released Apache 2.0 weights and serves the model through its API and dedicated Model Vault offering.^[1][3][4]

Release and scope

North Mini Code is designed for repository-level changes, terminal tasks, code review, codebase explanation, scientific programming, algorithmic problems, and coordination between coding subagents. Cohere's documentation recommends it for agent frameworks including SWE-Agent and OpenCode, as well as local coding workflows.^[1][3]

Scroll sideways for more →

Cohere's model page labels North Mini Code multilingual, but neither that page nor the model card lists supported natural languages or programming languages. Cohere also does not publish language-specific evaluation results. The available evidence therefore supports a multilingual label, not a defined language matrix. Although the model documentation displays a broad capability badge for image input, the more precise model card identifies the model as text-input and text-output only.^[3][4]

Architecture and context

North Mini Code is a decoder-only Transformer with 128 feed-forward experts. Eight experts are selected for each token, using a sigmoid router before top-k selection, and the expert blocks use SwiGLU activations. The network interleaves sliding-window attention with rotary positional embeddings and global attention without positional embeddings in a 3:1 ratio.^[2][4]

The distinction between total and active parameters is important. The model routes each token through enough experts to activate about 3B parameters, which reduces computation relative to using every parameter. The downloadable checkpoint still contains about 30B parameters. The 3B active figure is therefore not a 3B checkpoint size or a 3B-model memory requirement.^[2][4]

Cohere gives a 256K total context limit and a 64K output ceiling, but does not publish a long-context retrieval curve or results broken down by prompt length. The technical sources also omit the layer count, hidden dimensions, expert dimensions, tokenizer vocabulary, and sliding-window size.^[2][3][4]

Tool use and agent behavior

North Mini Code can emit structured tool use requests from tools defined through JSON Schema. This is a form of function calling: the model selects a tool and supplies arguments, while a surrounding agent framework validates the request, runs the command or code, and returns the observation. The model itself does not directly operate a terminal, edit a filesystem, or create subagents without that external system.^[2][4]

Cohere trained the model against three materially different coding interfaces. SWE-Agent exposes a rich command-line tool set, mini-SWE-agent uses a Bash-oriented interface with raw output, and OpenCode provides typed tools. In Cohere's account, adding a small amount of evaluation-harness data in the second supervised stage improved its OpenCode result by 10% while preserving SWE-Agent performance. The same post reports 61.0% pass@1 with mini-SWE-agent. These results suggest some transfer across agent frameworks, but they do not make agent setup irrelevant: prompts, tool schemas, token budgets, environment images, retries, and output parsing can all change an evaluation.^[2]

The model card provides examples for Transformers, vLLM, and SGLang. At release, some paths depended on development versions, including vLLM main, the response parser in Cohere's melody package, and OpenCode main. This made exact runtime compatibility more fragile than a mature, fully released integration matrix.^[4]

Post-training

Cohere describes a two-stage supervised fine-tuning process followed by reinforcement learning with verifiable rewards. The first supervised stage mixes programming, reasoning, and instruction-following data. Seventy percent of its tokens are code: 43% comes from agentic tool-use trajectories and 27% from single-turn competitive or scientific programming.^[2]

The second supervised stage uses 4.5 billion agentic and reasoning tokens, 61% of them code. Across the post-training program, Cohere reports more than 70,000 verifiable tasks drawn from about 5,000 unique repositories. Most are real-repository software-engineering tasks; the remainder include terminal tasks from internal and public sources. Environments are containerized, solutions are verified with tests, and some trajectories are generated synthetically. Cohere says the data was deduplicated against SWE-bench and SWE-bench Pro sources. The two supervised stages use 64K and 128K training contexts respectively.^[2]

The final stage combines repository and terminal tasks in one asynchronous reinforcement-learning system. It samples with vLLM, updates weights every four steps, uses the CISPO objective with token-level importance sampling and a leave-one-out baseline, and runs batches of 512 rollouts, grouped as eight attempts per prompt. A binary unit-test reward gives zero to invalid or unparseable tool calls. Cohere reports that this stage improved the supervised checkpoint by 7.9 absolute points on Terminal-Bench v2 and 3.0 points on SWE-bench.^[2]

An internal human evaluation compared the final checkpoint with the supervised checkpoint on 85 samples covering explanation, editing, data visualization, and from-scratch coding. The final checkpoint received a 66.1% aggregate preference rate. This measures an internal checkpoint change, not preference against a competing model.^[2]

Cohere does not disclose the complete pretraining corpus, a list of the roughly 5,000 repositories, pretraining token count, accelerator count, training duration, energy use, or total compute. No dedicated peer-reviewed North Mini Code paper or public training repository accompanied the release.^[2][4]

Evaluation

Cohere's published results cover agentic terminal and repository tasks plus non-agentic scientific and competitive code generation. The company says it averaged three seeds with temperature 1 and top-p 0.95. The following are North Mini Code's author-reported launch scores:^[1][2]

Scroll sideways for more →

SWE-bench Verified contains 500 human-validated software issues from 12 Python repositories. Its validation was intended to remove underspecified problems and unreliable tests from the original benchmark.^[8] The North result nevertheless remains a full agent-system score rather than a model-only constant. It depends on SWE-Agent, its commands and prompts, the environment, and the inference configuration.

SWE-bench Pro needs a stronger caveat. In July 2026, after North Mini Code's launch, OpenAI reported an audit estimating that about 30% of its tasks were broken. Problems included tests that did not reliably distinguish correct from incorrect patches. The audit does not retroactively recompute North's 40.2 score, but it limits how confidently that number can represent repository-engineering ability.^[9]

Cohere's competitor table is not a uniform third-party bake-off. Its footnotes say it combines public reports, Artificial Analysis results, scores attributed to other developers, and some competitor runs measured internally where public figures were missing. Hardware and harness differences therefore matter when interpreting rank or margin claims.^[1][2]

At launch, Cohere cited an Artificial Analysis Coding Index score of 33.4. On July 24, 2026, Artificial Analysis' current North Mini Code page instead showed an Intelligence Index v4.1 score of 20 and measured output speed of 49.2 tokens per second, describing the model as relatively slow or verbose for its class.^[7] These are different index versions and should not be treated as a score decline on one unchanged test. Cohere also reported up to 2.8 times the throughput of Devstral Small 2 on identical hardware and concurrency, plus 30% lower inter-token latency. Those speed comparisons were company-run and were not independently reproduced in the cited independent analysis.^[1][11]

Weights, API access, and pricing

Cohere Labs describes the release as open weights under the Apache License 2.0. Checkpoints are hosted on Hugging Face in BF16, FP8, and W4A16 formats. Cohere's launch post also names OpenRouter and OpenCode as access or integration routes.^[1][4]

Cohere states that FP8 or FP4 deployment can fit on one Nvidia H100. That is a vendor minimum for specified low-precision configurations, not a promise that BF16 weights, a full 256K prompt, every runtime, or high concurrency fits within the same memory.^[1][11]

Hosted access supports Cohere's Chat V2, Chat V1, and Chat Completions endpoints. The model documentation says both trial and production API use are free until their respective rate limits. Cohere's current rate-limit page lists 20 Chat requests per minute for trial keys and 500 per minute for production keys.^[3][5] No permanent per-token price is published, so the current free status should not be read as an indefinite pricing commitment.

For enterprise deployment, Cohere's model page names Model Vault, its dedicated single-tenant managed-inference service. General Model Vault documentation describes isolated deployments, a 99.9% service-level objective target, and optional zero-data-retention controls, but its public pricing table does not give a North Mini Code-specific figure.^[6] Downloading Apache-licensed weights avoids an API usage charge, while compute, storage, engineering, security, and operations remain the deployer's costs.

Safety and limitations

The model card has no dedicated safety, risks, or limitations section, and Cohere publishes no North Mini Code-specific secure-coding benchmark, cybersecurity evaluation, red-team report, or model-system card. Its tests measure task completion, not whether generated changes introduce vulnerabilities, fetch malicious packages, expose secrets, follow prompt injections in a repository, escalate privileges, or attempt destructive commands.^[2][4]

The unit-test reward used in training is a correctness signal, not a security guarantee. Tests can be incomplete, and a patch can pass them while weakening authorization, validation, privacy, reliability, or maintainability. Agentic deployment therefore requires controls outside the model, such as sandboxed execution, scoped credentials, network and command restrictions, audit logs, change review, and recovery procedures.

Cohere's Labs Acceptable Use Policy prohibits named harmful and abusive uses of its models and derivatives.^[10] That policy is distinct from a model-specific safety evaluation and should not be mistaken for evidence that North Mini Code resists malicious prompts or unsafe tool calls.

Other limits are matters of disclosure and deployment. The full pretraining data and language coverage are unknown, the longest context has no published reliability curve, current results are harness-sensitive, and several launch integrations required development versions. The checkpoint contains 30B total parameters despite activating about 3B per token. North Mini Code is consequently a compact-compute coding specialist, not a 3B general model, a self-executing agent, or evidence of safe unattended access to production systems.

References

1. Cohere. North Mini Code: An Open-Source Agentic Coding Model. June 9, 2026. ↩
2. Cohere Code Agents Team. Introducing North Mini Code. June 9, 2026. ↩
3. Cohere. North Mini Code 1.0. 2026. ↩
4. Cohere Labs. North-Mini-Code-1.0 model card. 2026. ↩
5. Cohere. API rate limits. 2026. ↩
6. Cohere. Model Vault. 2026. ↩
7. Artificial Analysis. North Mini Code: Intelligence, Performance and Price Analysis. Accessed July 24, 2026. ↩
8. OpenAI. Introducing SWE-bench Verified. August 13, 2024. ↩
9. OpenAI. Separating signal from noise: How we are auditing coding evaluations. July 8, 2026. ↩
10. Cohere. Cohere Labs Acceptable Use Policy. 2026. ↩
11. Developers Digest. Cohere North Mini Code: Open-Weight Coding Model. June 2026. ↩