Title card for MAI Code 2 vs North Mini Code. MAI Code 2 is shown as Microsoft's GitHub Copilot model at $0.50 input and $2.50 output per million tokens with a 1M context window, no weights and no published parameter count. North Mini Code is shown as Cohere's Apache 2.0 model at 30 billion total and 3 billion active parameters, a 256K context window, downloadable weights and a footprint that runs on one H100.
Engineering & Research

MAI Code 2 vs North Mini Code: A Rented Model Against a 30-Billion-Parameter Download

Author

jinhao.song

Date Published

Latest models · 20View all models →
Benchmarks: Artificial Analysis · updated daily
Back to all posts

The number that settles this matchup is not a benchmark. It is 3 billion — the active parameter count of North Mini Code, Cohere's Apache 2.0 coding model released on 9 June 2026, small enough to serve on a single H100. MAI Code 2 is the opposite proposition: Microsoft released it on 17 November 2026 as hosted inference inside GitHub Copilot, at $0.50 per million input tokens and $2.50 per million output, with no weights, no self-host path, and — this is the part that makes a capability comparison impossible — no published parameter count at all. Microsoft has not told anyone how big the model is. Cohere has told everyone exactly how big its is, down to the expert count. That difference in disclosure is a better guide to which model to pick than any score, because it tells you what each vendor expects you to do with it.

Why a capability comparison collapses immediately

North Mini Code is a 30-billion-parameter sparse mixture-of-experts model with 3 billion active parameters, a 256K context window, text in and text out, Apache 2.0 weights, and a footprint that fits one H100. Cohere trained it across several agent harnesses rather than pinning it to one — SWE-Agent, mini-SWE-Agent, OpenCode and Terminus 2 all appear in the company's material — because the point of an open model is that you bring your own agent.

MAI Code 2's published spec sheet has three items: a price, a 1 million token context window available in Visual Studio Code and Copilot CLI only, and a list of intended tasks. There is no parameter count, no output ceiling, no latency benchmark absent from the vendor's own harness. Its evidence is four named benchmarks and two ratios — 96% of Claude Opus 5.5's performance at 5% of the cost, 98% of GPT-6.1 Sol's at 40% — averaged across DeepSWE 1.1, Terminal Bench 2.1, SWE-Atlas and FrontierCode v1.1, with the first three run on Microsoft's internal MSBench platform and FrontierCode sourced from Artificial Analysis.

Those are not two points on one curve. One is a small model designed to be ubiquitous; the other is a large model designed to be rented, whose size you are not told. Comparing them on capability is not merely hard, it is undefined.

The cost of ownership, which is where the two actually differ

• Up-front cost — North Mini Code at the price of an H100 you already own or rent, against MAI Code 2 at zero beyond the Copilot seat you hold

• Marginal cost per token — North Mini Code at $0.00 per million on the API Artificial Analysis measures, against MAI Code 2 at $0.50 input and $2.50 output

• Cost after eighteen months — North Mini Code at whatever your GPU contract says, against MAI Code 2 at $1.00 and $5.00 from 17 May 2027, when the promotional rate expires and doubles

• Data residency — North Mini Code inside your own network, air-gappable, against MAI Code 2 in Microsoft's hosted inference under Microsoft's product terms

• Auditability — North Mini Code under Apache 2.0 with downloadable weights, against MAI Code 2, for which no weights are distributed

• Context — North Mini Code at 256K, against MAI Code 2 at 1 million tokens, VS Code and Copilot CLI only

• Operational burden — North Mini Code needs a serving stack, a quantisation decision and someone on call, against a model-picker selection

That last line is the one teams underestimate. Open weights are free the way a puppy is free. Serving a 30B model at production latency means vLLM or an equivalent, a tokenizer and chat template that match Cohere's reference, a quantisation that does not quietly destroy tool-calling reliability, and capacity planning for the peak rather than the mean. The pay-off is that the model keeps working when the vendor does not: no rate limit, no deprecation notice, no price change you did not approve.

Artificial Analysis measured the operational side and the reading is genuinely good — 180 tokens per second of output and $0.00 per Intelligence Index task, on the same page that reports a median of $0.30 per million output tokens across the models it tracks. This is a fast model. It is also, on the same page, a low-scoring one: an Intelligence Index of 3 under version 5.0.1. Speed is what you get instead of depth, and for autocomplete-shaped edits, lint fixes and test scaffolding that trade is correct. For repository-scale refactoring it is not.

Artificial Analysis page for North Mini Code showing an Intelligence Index of 3 against a median of 6, $0.00 per million input and output tokens, 180 tokens per second, 4.70 seconds to first token, 54.5 million tokens generated on the index run, a 256k token context window, 30 billion total parameters and 3 billion active parameters.

What Microsoft's numbers cover, and what they leave out

The honest summary of MAI Code 2's evidence is that it is directional and unverifiable. The direction is consistent — cheaper than the frontier by a wide margin, close to it on four coding benchmarks averaged together — and the verification is absent, because Microsoft published ratios rather than per-benchmark pass rates and Artificial Analysis has no row for the model as of 18 November 2026.

What that means concretely: you cannot compute attempts per finished task for MAI Code 2, so you cannot turn a token discount into a cost-per-merge figure. You can only take Microsoft's word that the average works out, on the four benchmarks Microsoft picked, with the harness Microsoft ran. The claim that MAI Code 2 delivers "changes code maintainers would merge" is the kind of statement that needs an absolute number behind it, and there is not one.

North Mini Code has the mirror-image problem. Its numbers are public and its scores are low — Cohere's own reported 61.0% pass@1 on SWE-Bench Verified is respectable for a 3B-active model, and the independent Intelligence Index of 3 is not respectable at all. Both are true, because a small model can pass a curated set of single-function tasks and still be weak on the long-horizon, multi-file work that the index rewards.

Where the free tier went, and why it matters here

North Mini Code's distribution story changed on 14 August 2026, when Cohere announced the model had passed 150,000 downloads and attributed much of the climb to a hosted gateway's free tier going away. That count is Cohere's own aggregate across every channel and not independently verified — the public Hugging Face repository shows a monthly figure an order of magnitude smaller — so read it as momentum.

The consequence is the part that matters. A developer who had been running North Mini Code for nothing now has three options: Cohere's own API, a managed deployment priced per instance, or the Apache 2.0 weights on hardware they control. Two of the three are self-hosting stories, which is exactly the point of open weights and exactly the cost this article has been describing.

MAI Code 2 carries no equivalent churn risk because it was never free-standing. It lives inside a Copilot subscription whose price Microsoft controls, at a token rate documented as promotional with a stated end date. The failure mode is different in kind: not a free tier vanishing, but a rate card doubling on a calendar date you can plan around.

Running the cheap side through one endpoint

Neither MAI Code 2 nor North Mini Code is on OrcaRouter's catalogue, and it would be wrong to imply otherwise. MAI Code 2's only published route is a Copilot seat; North Mini Code's is Cohere's own API, a managed deployment, or your own GPUs. What a routing layer changes is not access to those two models but the cost of the decision around them: the models you would fall back to — Claude Opus 5.5, Gemini 4 Carbon, Kimi K3.1 Pro, Qwen3.8-Max — sit behind one key at provider list price with 0% markup, so a comparison run against any of them bills at exactly the vendor's rate, and automatic failover means the cheap model you are testing never becomes the reason a pipeline stops.

The pattern that works for a team in this position is a two-tier split rather than a switch. Put North Mini Code, or a comparable small open model, on the routine tier where 3 billion active parameters is genuinely sufficient and the operational cost is already sunk. Put a measured frontier model on the tier that handles refactors and repository-scale reasoning. Then treat MAI Code 2 as a third lane available only to developers inside Copilot — useful for testing whether Microsoft's price-performance claim survives contact with your repositories, and not yet a candidate for anything a build server has to call.

The decision, in a form a team can act on

Choose North Mini Code if the requirement is that the model runs where you run — regulated data, an air-gapped network, a factory floor with no reliable egress — or if you have GPU capacity that is already paid for and idle. The Apache 2.0 licence and the one-H100 footprint are the whole argument, and they are strong ones. Accept in exchange that you are buying a 3B-active model's capability, that the independent score is 3 out of the index, and that you now own the serving stack.

Choose MAI Code 2 if your developers already work in Copilot and the work is routine enterprise repair where a four-fold price advantage over the frontier matters more than an audited score. Accept that the model is not yours, cannot be audited, has no published size, and doubles in price in May 2027.

Do not choose between them on benchmark numbers. North Mini Code is measured and small; MAI Code 2 is unmeasured and, by its own vendor's account, tuned for the everyday rather than the hard. One of those is a fact you can check and the other is a claim you cannot, and neither is a comparison.

Cohere's blog post headed 'Introducing North Mini Code: Cohere's first model for developers', dated June 9, 2026, with a three-minute read time and a lede describing a small, efficient, open-source agentic coding model.

Both models do share one lesson, which this blog keeps running into. The free hosted tier went away for one. The promotional rate has an end date printed on the other. A team whose architecture assumes either will hold is a team that will be rewriting something at short notice.

Scoreboard comparing MAI Code 2 and North Mini Code across six dimensions. Total parameters not published versus 30 billion, active parameters not published versus 3 billion, context 1M tokens versus 256K tokens, price $0.50 and $2.50 versus $0.00 per million tokens, weights not distributed versus Apache 2.0, and independent index no entry versus 3.

Compared in this article1

Detected from this article · Benchmarks: Artificial Analysis · updated daily