Microsoft's Coding Model Stops Playing Second Fiddle: MAI Code 2 Scores 96% of Opus 5.5 for 5% of the Cost — Read the Three Caveats First
On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.

In one sentence: Microsoft's coding model is no longer a sideshow
On 17 November 2026, Microsoft unveiled MAI Code 2 and MAI Code 2 Flash at its Ignite conference — two coding models trained from scratch in-house — and put both in GitHub Copilot's model picker the same day. This is not Microsoft's first coding model: October's MAI-Code-1.1-Flash was a lightweight sidekick, good for explaining code and small edits. This time is different. The larger MAI Code 2 is aimed squarely at flagships like GPT-6.1 Sol and Claude Opus 5.5, while the smaller Flash goes after the price-performance of everyday, high-volume work. Microsoft also published a 22-page model card, laying out parameter counts, training data volumes, benchmark scores and safety evaluations — including the parts that do not look good.
This article covers five things: what the two models actually are, how Microsoft arrived at "96% of the score for 5% of the price", the three caveats behind those numbers, who can use them, where, and for how much — and what the model card's less flattering safety pages say.
Two models: one for heavy lifting, one for high-volume work
MAI Code 2 and Code 2 Flash come from the same model family: a decoder-only Transformer with sparse mixture-of-experts layers and an integrated vision encoder, sharing the training recipe and data mix, differing mainly in scale. The larger MAI Code 2 has 77 billion active parameters out of roughly 2.8 trillion total, pre-trained on about 50 trillion tokens plus another 150 billion tokens to stretch context to one million. The smaller Flash has 12 billion active parameters out of roughly 398 billion total, pre-trained on about 25 trillion tokens — 22 trillion text and 3 trillion image — using logit distillation from a larger in-house MAI teacher model. Both accept text and image input, with a context window of 1,050,000 tokens, a 922,000-token input limit and a 128,000-token output limit, and reasoning effort adjustable across five levels — low, medium, high, xhigh, max — trading latency and cost for quality.
Microsoft is blunt about the division of labour. The large model handles "take code to production" work: deep debugging, multi-file implementation, refactoring, reasoning across a whole repository, building interfaces. Flash handles high-volume work: code explanations, targeted edits, routine fixes, rapid iteration. Neither is built for general chat: the model card states they were not designed or evaluated for general-purpose consumer chat, medical, legal or financial advice, and should not be used for consequential decisions about people without qualified human review.
One training detail is worth noting: reinforcement learning ran directly inside the GitHub Copilot CLI and VS Code agent harnesses used in production, so improvements learned offline transfer to real developer workflows. Many models are evaluated in bare test harnesses divorced from the product, where scores look good but may not survive contact with real use. Microsoft ran its evaluations in the same Copilot CLI harness, which at least narrows the "grading your own homework" gap a little.
Both models share a vision encoder, so screenshots, UI mockups and charts can be fed in as input. Microsoft lists image-to-code as a core capability, and the 64% blind-test preference rate was earned on frontend app tasks. For people building apps, that means sending a screenshot and getting a first draft may become a routine move rather than a party trick. How reliable the visual ability really is will only be clear once real users try it — the model card gives no separate score for vision tasks.
Why now: Microsoft wants the model business in its own hands
To understand this launch, look at where it sits. The MAI Code 2 family was trained end to end by Microsoft — not a fine-tuned rebrand of someone else's model. The previous generation, MAI-Code-1.1-Flash, was a 5-billion-active-parameter lightweight, mostly explaining code; a month later the 2 family jumps to 77 billion active parameters aimed at complex, long-horizon software engineering. The launch was timed to Ignite's opening day, with the models in Copilot's picker the same day and a batch of other new models announced alongside. The message is plain: Microsoft no longer wants "Microsoft's coding model" to mean a supporting act.
The rollout order is also worth reading. First stop is Copilot, Microsoft's largest developer surface, reaching every subscriber on launch day. Second is Foundry, with an API for developers building their own apps and agents. Only third come third-party platforms — OpenRouter, Vercel, Hermes, OpenCode and Kilo — named on the roadmap with no dates attached. Own users first, then the platform, then the outside market: a deliberately restrained expansion. Pricing follows the same logic: a 50% promotional discount until 17 May 2027, buying adoption first and worrying about standard prices later.
One more piece of context matters. Microsoft is OpenAI's biggest partner and is now also raising its own models. The MAI Code 2 launch does not displace anything in Copilot — GPT-6.1 Sol, Claude Opus 5.5 and the Gemini 4 family all stay in the picker, and Fusion's automatic routing keeps working. Microsoft's play is not "replace the others" but "put one more option on our own shelf — and make it the cheap one". For users, that makes the competition in the picker concrete for the first time: the gap between an expensive model and a cheap one can now be counted in cents per task.
The headline numbers: 96% of the score, 5% of the price
Microsoft's launch post is titled around its theme: everyday coding at scalable prices. The headline figure is an average over four benchmarks aimed at the everyday enterprise coding tasks Microsoft sees in GitHub Copilot — DeepSWE 1.1, Terminal Bench 2.1, SWE-Atlas and FrontierCode v1.1. By Microsoft's math, MAI Code 2 averages a 63.2% pass rate, against 64.1% for GPT-6.1 Sol and 65.3% for Claude Opus 5.5. The three models are within two points of each other. Average cost per task, though, is far apart: $0.309 for MAI Code 2, $0.761 for GPT-6.1 Sol and $6.306 for Claude Opus 5.5. In Microsoft's words, that is 98% of GPT-6.1 Sol's performance at 40% of the cost, and 96% of Claude Opus 5.5's performance at 5% of the cost.
The model card also gives per-benchmark numbers for three of the four, showing the real gap between the two siblings. On DeepSWE 1.1, Code 2 scores 73.2% against Flash's 59.9%; on TerminalBench 2.1, Code 2 scores 84.6% against Flash's 78.3%; on SWE-Atlas they are nearly tied, Code 2 at 43.1% with Flash slightly ahead at 44.8%. In other words, Flash is clearly weaker on terminal tasks and deep software engineering, but gives nothing away on code Q&A, test writing and refactoring. That matches the role Microsoft assigned it: the small model is for high-volume small jobs, not for the heavy ones.
Flash has its own comparison set, not the flagships: Microsoft says it matches GPT-6 Luna and Claude Haiku 5.5 on three benchmarks for day-to-day, high-volume routine coding, at 65% and 20% of their cost. One more number comes from blind frontend evaluations: 258 reviewers, not knowing which model produced which app, preferred MAI Code 2's results over GPT-6 Sol's 64% of the time on aesthetics and functionality. That figure was revised from 67% to 64% after publication; the blog now says 64%.
Three caveats, before anything else
The numbers look good, but three caveats need to be stated first, or the headline will mislead.
The first is about price. The "5% of the cost" headline is calculated at promotional prices. On GitHub's pricing page, MAI Code 2 costs $0.50 per million input tokens, $0.025 cached input and $2.50 output until 17 May 2027; after that, standard pricing doubles it to $1.00, $0.05 and $5.00. Flash costs $0.05, $0.005 and $0.25 on promotion, doubling after the same date. Recomputing at standard prices puts MAI Code 2 at roughly $0.62 per task — still below GPT-6.1 Sol's $0.761 and far below Opus 5.5's $6.306 — but the "5%" figure itself only holds during the promotional window. After May 2027, the story has to be retold.
The second caveat is about the scores. MAI Code 2's 63.2% average is the lowest of the three. Microsoft's headline is about value, not the top of the table: 96% of the score for one twentieth of the money is a good deal, but if you want the highest-scoring model, MAI Code 2 is not it. The methodology is also entirely Microsoft's own: the MSBench evaluation platform, the GitHub Copilot CLI 1.0.102 harness with subagents disabled, maximum reasoning effort, three runs per task averaged, infrastructure errors counted as failures. Those conditions apply equally to all three models, but the experiment design, benchmark choice and cost accounting are the vendor's, and no independent reproduction exists yet.
The third caveat is about the capability boundary, and Microsoft wrote it into the blog and the model card itself: the models are "explicitly not yet tuned for harder problems, like fundamental science research and very long-horizon agentic work". Their comfort zone is everyday enterprise coding — implementing features, debugging, refactoring, building interfaces. Beyond that circle, such as running a research project from scratch or a months-long agent task, Microsoft makes no promises. The model card adds more: at release the model is optimized for English code production only, knowledge stops at August 2026, long agent sessions can repeat tool calls, under-use the existing codebase, drift from instructions or stop before fully verifying their work, and higher reasoning effort does not always improve results.
Who gets it, where, and for how much
Both models entered GitHub Copilot on launch day. MAI Code 2 is available on Copilot Pro, Pro+, Max, Business and Enterprise; Flash covers more ground, including Free and Student, though free and student users can only reach it through automatic model selection, not by picking it manually. Both models are available to eligible subscribers on annual plans only. The picker is everywhere Copilot is: VS Code, Visual Studio, Copilot CLI, the cloud agent, the Copilot app, github.com, GitHub Mobile, JetBrains IDEs, Xcode and Eclipse. Flash has one extra destination: a limited-access preview in Microsoft Foundry, callable through an OpenAI-compatible Responses API for custom applications and agents.
Billing is usage-based, through Copilot's AI credits, where 1 credit equals $0.01. At promotional prices, Code 2 costs $0.50 per million input tokens and $2.50 output; Flash costs $0.05 input and $0.25 output. For comparison, Claude Opus 5.5 in Copilot costs $4.00 input and $20.00 output. Even at the standard prices that apply after 17 May 2027, Code 2's input and output prices are a quarter of Opus 5.5's. Microsoft says the models will come to OpenRouter, Vercel, Hermes, OpenCode and Kilo later, with no timetable.
Existing users of the previous generation should note one date: MAI-Code-1.1-Flash is scheduled to retire on 18 December, and any saved setting that names it needs to be changed before then. From 1.1 to 2, Microsoft's coding model went from a lightweight assistant to a general-purpose model for heavy work in about a month — the pace itself is a signal that this family is still climbing fast, and today's conclusions may age quickly.
The less flattering page in the model card: safety
The model card pages most worth reading are not the benchmark tables but the safety evaluations. Microsoft rates two tracked risks High: chemical, biological, radiological and nuclear weapons (CBRN), and offensive cyber operations. The reason, in the card's words, is that evaluations indicate the models "could help medium skilled adversarial actors develop known CBRN weapons and could help expert adversarial actors develop novel CBRN weapons", and "could help a low-to-medium skilled actor create and conduct highly disruptive or destructive cyber-attacks". Microsoft says the rating matches other models in the class, naming GPT-5.6 Luna and GPT-5.6 Sol, and that deployments carry mitigations: a two-tier biosafety and cybersafety classifier plus abuse monitoring.
On specific numbers, AgentHarm — which measures how often an agent fully carries out explicitly malicious multi-tool tasks — shows harmful completion rates of 11.68% for Code 2 and 10.23% for Flash, where lower is safer. AgentDojo's attack success rate is 0.02% and 0.00% respectively, with utility — completing the user's real task — at 84.73% and 88.08%. SABER's "safe and capable" score is only 39.96% and 41.20%; OpenAgentSafety's "safe and complete" score is 39.92% and 37.01%. The message is consistent: judged on "finish the job without doing harm", both models are far from worry-free. The card's own conclusion leaves room too: in internal evaluations, the MAI Code 2 family is "similar in alignment to GPT-5.6 Sol but less aligned than GPT-6".
The mitigations are spelled out concretely. A two-tier classifier runs in real time over conversations: a fast first tier decides whether input or output touches the bio or cyber domain; anything flagged escalates to a second tier, a specially trained safety reasoner that maps the response onto a threat taxonomy and blocks high-risk responses. Repeated second-tier violations escalate to human review, with remedies ranging from customer notification to service suspension. Microsoft's advice to developers is practical: treat model output as a draft, review, test and security-scan generated code before merging, keep humans in the loop for actions with side effects, run agents in sandboxed environments with least-privilege access, and watch for prompt injection from untrusted repository content, web pages and tool output. That advice applies to any coding model — but Microsoft putting it in its own model's official documentation at least shows the vendor is not pretending the problem does not exist.
How this relates to what we have already published
Microsoft's coding models are not new to this site. An October article covered MAI-Code-1.1-Flash, a 5-billion-active-parameter lightweight built for quick assistance inside Copilot; this article's MAI Code 2 is a 77-billion-active-parameter general-purpose model aimed at complex, long-horizon software engineering, and Flash is a new 12-billion-active-parameter base. Between generations it is not just scale: context grew to 1.05 million tokens, reasoning effort became configurable across five levels, and reinforcement learning now runs directly in Copilot's production harnesses. The October piece is the starting point for this family; this one shows what it became a month later.
The other boundary is the 28 October Copilot Fusion GA article. Fusion is Copilot's multi-model routing — pick an effort level, Standard, High or Max, and let the system assign models per task — and MAI Code 2 has since joined Fusion's Standard tier. The relationship is simple: Fusion decides which model does a job, and MAI Code 2 is one of the models that can be chosen. Use Fusion when you want automatic assignment; pick MAI Code 2 manually when you want to know exactly which model is doing the work. This article does not repeat Fusion's three tiers and three execution patterns; it covers the new model itself.
For people building apps: try Flash first, then decide about switching
For Copilot users building apps, the practical way to try this is in two steps. First, hand everyday small jobs to Flash: explaining code, targeted edits, routine fixes, fast iteration. It is reachable on Free and Student plans through automatic model selection and is the cheapest tier in the whole picker — see how it behaves in your own repository first. Second, for heavier work — cross-file refactoring, deep debugging, reasoning across a whole repository — switch manually to MAI Code 2 and run the same task against the model you use today, with the same prompt and the same repository, and compare whose changes are cleaner and whose work needs less rework.
Three things to record while trying it. First, promotional pricing ends on 17 May 2027 — redo the maths at standard prices before making it part of a long-term budget. Second, Microsoft itself says long-horizon agent work and fundamental science research are outside these models' comfort zone, so do not test them there. Third, take the model card's stated limits seriously: performance outside English and on less common languages and frameworks has not been extensively evaluated, knowledge stops at August 2026, and quality can degrade in very long sessions. A trial result is only valid for your own repository and your own tasks — nobody else's benchmark scores substitute for your own comparison.
Finally, three dates worth watching. The first is 18 December, when MAI-Code-1.1-Flash retires and old settings need updating. The second is when the third-party platforms go live — there is still no date for MAI Code 2 on OpenRouter or Vercel. The third is independent reproduction: so far every benchmark number comes from Microsoft's own MSBench and Copilot CLI harness, and whether a third party reproduces anything close is the key test of how solid "96% of the score for 5% of the price" really is. Until those three questions have answers, this article's verdict stays provisional.
Comments (0)
Sources
Related articles
On 17 November 2026, Perplexity launched the Orchestrator API: one interface reaching OpenAI, Anthropic, Google, xAI and open-weight models such as GLM, Kimi and DeepSeek, billed at the answering model's published rate with no platform fee. When one provider fails, the same model retries on another deployment, and preview routing assigns requests to models by task.
On 11 November 2026, AWS open-sourced UAEF: adapters turn traces from LangGraph, LangChain, Strands and Bedrock AgentCore into one format, then 36 metrics across 7 dimensions score them, flagging regressions past 5%. The judge model is hardened too — scores must cite verbatim evidence, and never decide safety.
On 10 November 2026, Amp launched Boxes: always-on mini-computers from $18 a month for deploying software you built with an agent. Each box runs its own runner, so the agent can edit live production data right there; the same month Amp also shipped Spaces, retired the Dial, and arrived on Windows — the agent's workplace is moving off the laptop into the cloud.