Back to articles

AI models

MAI Code 2: Benchmarks, Price and Real Cost per Task (2026)

MAI Code 2 benchmarks, prices and real cost per task: where Microsoft's 96%-at-5% claim holds, where it breaks, and what changes on May 17, 2027.

MAI Code 2AI CodingBenchmarksPricingCost Per Task
O-mega Team
O-mega Team
•

67 min read

Microsoft's new coding model is cheap enough to change how teams buy AI coding. The headline ratio, though, rests on a half-price promotion and a carefully chosen test set. This guide prices MAI Code 2 per finished task, benchmark by benchmark, and shows where it wins and where it should not be trusted.

On November 17, 2026, Microsoft opened Ignite with seven new MAI models and led with two: MAI Code 2 and MAI Code 2 Flash, generally available the same day in GitHub Copilot - GitHub Changelog. The claim that traveled was simple. Averaged over four coding benchmarks, MAI Code 2 delivers 98% of the performance of OpenAI's GPT-6.1 Sol at 40% of the cost, and 96% of Claude Opus 5.5's performance at just 5% of the cost - Microsoft AI. In GitHub's price list, MAI Code 2 costs $0.50 per million input tokens and $2.50 per million output tokens, against $4 and $20 for Claude Opus 5.5 - GitHub Docs.

Those numbers are real, and they come with fine print that changes the decision. The MAI prices are a 50% promotion that ends on May 17, 2027, after which they double - GitHub Docs. Every model in Microsoft's comparison ran at max reasoning effort, the setting at which Claude Opus 5.5 spends roughly five times the output tokens it uses at its default - Artificial Analysis. The four benchmarks were chosen because they "target the everyday enterprise coding tasks we see in GitHub Copilot," and Microsoft says the models are "explicitly not yet tuned" for very long-horizon agentic work - Microsoft AI. On a harder benchmark tucked into its own model card, MAI Code 2 scores 26.3% - Microsoft AI model card. And OpenAI shipped GPT-6.2 Sol the same day, at GPT-6.1 Sol's prices but with fewer output tokens per task, so Microsoft's chosen baseline was a generation old on launch day - OpenAI.

None of that makes MAI Code 2 a bad model. On Microsoft's own data it is the cheapest credible option in the Copilot picker for well-specified everyday work, and its small sibling, MAI Code 2 Flash, beats both OpenAI's and Anthropic's small models on every benchmark Microsoft published. The point is that "96% at 5%" is an average of four tests at one effort setting at a promotional price, and your bill will be none of those things. This guide rebuilds the comparison from the underlying data. It covers what Microsoft launched and how the model was built, the full price list and what changes in May 2027, every benchmark and cost per task, five assumptions the headline hides, where the model breaks, the first-principles economics of why it is cheap, the Flash model, what it costs inside each Copilot plan, a reusable cost-per-task model with break-even math, the safety findings, and how it compares with the rest of this week's market.

This guide reflects prices, plans and benchmark results as published on November 19, 2026. Promotional prices, Copilot plans and model checkpoints change often (GitHub describes MAI models as continuously updated), so verify current details before committing a budget.

Contents

  1. The Short Answer: What MAI Code 2 Is Good For, and What It Costs
  2. What Microsoft Launched at Ignite 2026
  3. Inside MAI Code 2: Architecture, Training and the Copilot Data Loop
  4. The Price List: Promotional, Standard and Everything Around It
  5. The Benchmarks, Line by Line
  6. Decoding "96% at 5%": Five Things the Headline Hides
  7. Where MAI Code 2 Falls Short
  8. Why It Is So Cheap: The Economics From First Principles
  9. MAI Code 2 Flash: The Model That May Matter More
  10. What MAI Code 2 Costs Inside GitHub Copilot
  11. A Cost-per-Task Model You Can Reuse
  12. Safety, Alignment and What Happens to Your Code
  13. MAI Code 2 Against the Field This Week
  14. Which Model to Run: A Decision Guide
  15. Outlook: What Microsoft's Own Models Mean for Coding Prices

1. The Short Answer: What MAI Code 2 Is Good For, and What It Costs

Before the detail, the verdicts. Each row names the model in the Copilot picker that gives the best value per finished task for that kind of work, using Microsoft's published benchmark data at max effort unless noted. "Finished" matters: a model that fails more often must be re-run, reviewed or replaced by a person, and all of that is part of its real cost. Every figure is explained and sourced in the sections below.

Type of workBest valueThe evidence in one line
Well-specified terminal and DevOps tasksMAI Code 2Terminal-Bench 2.1: 84.6% at $0.081 per task vs GPT-6.1 Sol 85.0% at $0.265 and Opus 5.5 78.7% at $1.84
Multi-file changes graded by testsMAI Code 2 until May 17, 2027, then GPT-6.x SolDeepSWE 1.1: 73.2% at $0.618 vs Sol 74.6% at $1.21; at standard price MAI costs about the same as Sol
Merge-ready changesMAI Code 2 over Sol; Opus 5.5 when failures are costlyFrontierCode v1.1: MAI 52.0%, Sol 49.4%, Opus 56.0% at 27 times MAI's cost
Codebase comprehension, tests, refactoringGPT-6.x Sol or Opus 5.5SWE Atlas: MAI 43.1%, Sol 47.4%, Opus 57.5%; Sol wins whenever a failure costs you over $9
High-volume explanations and small editsMAI Code 2 Flash61.0% average at $0.052 per task vs GPT-6 Luna 55.1% at $0.080 and Haiku 5.5 53.9% at $0.319
Hard, long autonomous runsA frontier model (Fable 5.2, GPT-6.2 Astra, Opus 5.5)MAI Code 2 scores 26.3% on Terminal-Bench 4 in its own model card; Microsoft says it is not tuned for this
UI from screenshots and mockupsMAI Code 2 (vendor data only)Developers preferred its frontend output over GPT-6 Sol 64% of the time in Microsoft's blind test

The pattern is consistent enough to state as a rule. MAI Code 2 is the value choice wherever the task is well specified and checked by tests, which describes most of what developers ask Copilot to do on an ordinary day. It is not the value choice where the task demands judgment about an unfamiliar codebase, or where the run is long and autonomous enough that one failure costs more than a month of token savings. And its advantage is temporary in one specific way: half of it disappears on May 17, 2027, when the promotion ends.

2. What Microsoft Launched at Ignite 2026

MAI Code 2 arrived as the lead item in a coordinated release. Microsoft AI announced seven new models at Ignite under the banner "scalable price-performance": MAI Code 2, MAI Code 2 Flash, MAI Cyber 2 Flash for agentic cyber defense, MAI Image 2.7 for image generation and editing, MAI Realtime 1 for live speech-to-speech, Dragon Copilot Transcribe for medical transcription, and Decision 1.1, a model-routing model that Microsoft says is 50 times faster and 79 times cheaper than GPT-6.1 Sol - Microsoft AI. Alongside them came the Maia 200 accelerator and MAI Licensed Weights, which Satya Nadella described as letting "our trusted customers" get access to Microsoft AI model weights - Official Microsoft Blog.

The keynote framed the whole lineup around one idea. "We don't just hill-climb on frontier quality alone. We co-optimize quality and price together," Microsoft AI's presenter said, and, on why enterprises want models Microsoft owns: "No one wants to pour their IQ into someone else's model" - Microsoft AI keynote transcript. The MAI segment of the opening keynote starts at the 1:34:57 mark of Microsoft's recording.

On stage, the claims match the launch post: "98% of the performance of GPT 6.1 Sol at just 40% of the cost," and a Flash model that "matches 6 Luna and Haiku 5.5 on these everyday tasks, at just 65% and 20% of the price" - Microsoft AI keynote transcript. The per-benchmark data and the methodology sit in the launch post's footnotes and in the model card, which is where the rest of this guide takes its numbers from.

Where you can use it

GitHub made both models generally available the same day. MAI Code 2 is in Copilot Pro, Pro+, Max, Business and Enterprise; MAI Code 2 Flash reaches those plans plus Copilot Free and Student. They appear in the model picker in Visual Studio Code, Visual Studio, Copilot CLI, the Copilot cloud agent, the GitHub Copilot app, github.com, GitHub Mobile, JetBrains, Xcode and Eclipse, are "built for agentic coding workflows," and are billed under usage-based billing. One line in the changelog is worth quoting exactly, because its scope is unclear: "Both models are available to eligible GitHub Copilot subscribers on annual plans" - GitHub Changelog.

Outside Copilot, availability is thinner than some coverage suggests. Microsoft AI's launch post says Code 2 Flash "is in limited-access preview in Microsoft Foundry" and that both models will come "soon" to OpenRouter, Vercel, Hermes, OpenCode and Kilo - Microsoft AI. Nadella's blog post says both models are "also available in Foundry," but Azure's Foundry model price page lists no MAI Code 2 entry - Azure, and as of November 19 neither OpenRouter's nor Vercel's public model lists include them. Kilo describes the models as "coming in private preview" - Kilo. For now, MAI Code 2 is a Copilot model.

There is a similar discrepancy about routing. Nadella wrote that the models are available "both in the model picker and as part of Copilot Fusion." GitHub's documentation of the models that auto model selection and Copilot Fusion can choose lists MAI Code 2 Flash but not MAI Code 2 - GitHub Docs. In practice that means Flash can be chosen for you, while MAI Code 2 has to be chosen by you.

How the MAI coding line got here

MAI Code 2 is the third generation of a line that only began this year. GitHub's model retirement history shows MAI-Code-1-Flash retired from Copilot on September 10, 2026, with "Latest MAI-Code model" as the suggested alternative - GitHub Docs. On launch day GitHub announced it will deprecate MAI-Code-1.1-Flash "across all GitHub Copilot experiences on December 18, 2026" - GitHub Changelog. The model card says the new family is built on "new, larger pre-trained bases" compared with MAI-Code-1.1-Flash's 5 billion active parameters, and adds the one-million-token context and configurable reasoning effort that the earlier model lacked - Microsoft AI model card.

The pace of improvement is the striking part. MAI-Code-1-Flash reached Copilot on June 2, 2026 - GitHub Changelog. In July, Microsoft AI reported that its Copilot model had an "approximately 10% higher code accept rate than GPT 5.4 Mini and Claude Haiku 4.5 in VS Code," and that it could be served on older H100 and A100 class GPUs - Microsoft AI.

MAI-Code-1.1-Flash followed in August, billed as "better, faster at a quarter of the cost" with "a 22% improvement on Terminal-Bench 2.1" - Microsoft AI. It still drew a harsh reception: The Decoder tabulated its Terminal-Bench 2.1 score at 62.9% against 82.7% for DeepSeek V4 Flash 0731 and concluded it "gets crushed by DeepSeek on both price and performance" - The Decoder. Three months later, MAI Code 2 Flash posts 78.3% on the same benchmark at lower token prices than the model it replaces, and MAI Code 2 posts 84.6%. Whatever one thinks of the headline ratios, that is a fast learning curve.

The strategic backdrop explains the pace. The October 2025 restructuring of the Microsoft-OpenAI partnership stated that "Microsoft can now independently pursue AGI alone or in partnership with third parties" - Official Microsoft Blog, and an April 2026 amendment made Microsoft's license to OpenAI's technology non-exclusive while ending Microsoft's revenue-share obligation to OpenAI - The Register. A company that resells OpenAI and Anthropic models to its Copilot users, and is no longer bound to one partner, has every reason to fill the cheapest, highest-volume slot in its own picker with its own model.

The screenshot GitHub published with the launch shows the new models sitting in the same picker as GPT-6.1 Sol and the outgoing MAI-Code-1.1-Flash. That placement is the whole distribution strategy: no new tool to install, no new contract, one click away for every paid Copilot seat.

3. Inside MAI Code 2: Architecture, Training and the Copilot Data Loop

Most launch coverage stopped at the headline percentages. The more revealing document is the 22-page model card Microsoft published the same day, which describes what the model is, how it was trained and where its makers think it breaks - Microsoft AI model card. Read it before you read any benchmark, because the architecture explains the price and the training explains the benchmark profile.

A very sparse giant

Both models are decoder-only transformers with sparse Mixture-of-Experts layers and an integrated vision encoder, pre-trained and post-trained by Microsoft from scratch. MAI Code 2 has about 2.8 trillion total parameters but only 77 billion active per token (80 billion counting embeddings), and was pre-trained on roughly 50 trillion tokens before a 150-billion-token extension to a one-million-token context. MAI Code 2 Flash has about 398 billion total and 12 billion active parameters, and was pre-trained on about 25 trillion tokens by distilling from a larger in-house MAI teacher. One caution about the card itself: its summary table lists MAI Code 2's size as "50B-100B (80B active)," which only makes sense as a band for the active count, while the body gives the 2.8 trillion total. Treat the body as the description of the model.

Why does that ratio matter to a buyer? In a Mixture-of-Experts model, each token passes through only a small subset of the network. The compute a token costs scales roughly with the active parameters, while the memory needed to hold the model scales with the total. MAI Code 2 activates under 3% of its weights per token. That is the design of a model built to be served cheaply at enormous volume: a large reservoir of knowledge, a small bill per token. Section 8 follows that thread into the price.

Specs that matter in practice

SpecMAI Code 2MAI Code 2 Flash
Total / active parameters~2.8T / 77B~398B / 12B
Context window1,050,000 tokens1,050,000 tokens
Max input / output922,000 / 128,000 tokens922,000 / 128,000 tokens
InputsText and imagesText and images
Reasoning effortLow, medium, high, xhigh, maxLow, medium, high, xhigh, max
Language focusEnglish code productionEnglish code production
DistributionGitHub Copilot (all clients)GitHub Copilot, Foundry (limited preview)
WeightsNot distributedNot distributed

The card states the context, input and output limits, the image input and the five effort levels for both models, and adds that weights are not distributed and the models run on Azure GPU infrastructure. GitHub's documentation adds a practical limit: the one-million-token window is available only in Visual Studio Code and Copilot CLI, configurable reasoning only in VS Code, Copilot CLI and the cloud agent, and "choosing a larger context window or higher reasoning will impact AI credits consumption" - GitHub Docs. If you work in JetBrains, Xcode or on github.com, you get a smaller window and the default effort.

Trained inside the product it serves

Three training choices explain why MAI Code 2 behaves like a Copilot specialist rather than a general model.

Reinforcement learning ran in the production harness. The card says large-scale reinforcement learning "was run directly in the GitHub Copilot CLI and VS Code agent harnesses used in production, so that offline improvements transfer to real developer workflows." A model trained in a lab's own harness has to carry its behavior over to whatever harness you run. Microsoft trained in the exact tool loop its users run, which is one reason its scores in that loop look strong, and one reason you should not assume they transfer to a different harness such as Claude Code, Cursor or your own agent.

Copilot users' prompts shaped the tasks. The data card discloses that conversation contexts (prompts and associated context, not responses) from Copilot Free, Pro and Pro+ users who had not opted out were used to construct software-engineering tasks for post-training, after filtering out identifying and safety-sensitive content - Microsoft AI data card. Business and Enterprise plans are not named in that disclosure. Post-training spanned more than 1.4 million task prompts and about 166 billion trained tokens across 16 task families.

OpenAI's models generated synthetic training data. The same data card names GPT-5.6 Sol and GPT-6 Astra as the commercially available models used to generate synthetic data for post-training. In plain terms, part of what MAI Code 2 learned came from OpenAI models, which helps explain how a lab that shipped its first coding model this year reached near-frontier scores on everyday tasks so quickly.

Put together, this is a distribution flywheel: Copilot's own users produce the task data, the production harness is the training environment, and a frontier partner's models supply synthetic examples. The result is a model tuned to the median Copilot request. That is a strength for the median request and a limitation for everything else, which is exactly the shape of the benchmark results.

4. The Price List: Promotional, Standard and Everything Around It

GitHub publishes every Copilot model's price per million tokens on one page, and for the models that labs also sell directly, the Copilot price matches the lab's list price. That makes it the cleanest place to compare MAI Code 2 with everything it competes against - GitHub Docs:

ModelInputCached inputOutputNotes
MAI Code 2 Flash (promo)$0.05$0.005$0.25Until May 17, 2027
MAI Code 2 Flash (standard)$0.10$0.01$0.50From May 17, 2027
GPT-6 Luna$0.10$0.01$0.50Doubles input above 272K tokens
Claude Haiku 5.5$0.10$0.01$0.505x on prompts over 100K tokens
MAI-Code-1.1-Flash$0.20$0.02$1.20Previous MAI coding model
MAI Code 2 (promo)$0.50$0.025$2.50Until May 17, 2027
MAI Code 2 (standard)$1.00$0.05$5.00From May 17, 2027
GPT-6.1 Sol$2.00$0.10$10.00Microsoft's comparison baseline
GPT-6.2 Sol$2$0.10$10Released Nov 17, same price as 6.1
Claude Sonnet 5.5$2$0.10$10No long-context surcharge
Claude Opus 5.5$4$0.20$20Defaults to medium effort
Claude Fable 5.2$8$0.20$40Off by default on Copilot Business and Enterprise
GPT-6.2 Astra$8$0.40$40Higher rates above 272K tokens

Four details on that page matter more than the headline numbers.

The promotion has a date. Both MAI models are listed at promotional prices "until May 17, 2027," with the standard prices stated alongside. Six months is long enough to build habits and workflows around a price that will double, which is presumably the point. Budget on the standard column.

MAI shows no cache-write price and no long-context tier. The current OpenAI and Anthropic models on GitHub's list charge 1.25 times the input price to write new context into the cache, and several carry long-context surcharges: GPT-6.x models above 272,000 input tokens, Claude Haiku 5.5 above 100,000. The MAI rows list neither. For long agent sessions on big repositories, where the context grows with every turn, that is a structural advantage on top of the headline price, and it holds after the promotion ends.

Completions do not count. Code completions and next edit suggestions are not billed in AI credits and are "unlimited for all paid Copilot plans," according to the same page. Model choice affects chat, agent mode, the CLI and the cloud agent, which is where the money goes.

One AI credit is one cent. Copilot converts token costs into GitHub AI Credits at $0.01 per credit, so a task that costs $0.31 on MAI Code 2 consumes 31 credits, and one that costs $6.31 on Opus 5.5 consumes 631.

What the price curve says

The price curve tells a story about Microsoft's strategy. MAI-Code-1.1-Flash, the previous model, lists at $0.20 input and $1.20 output. MAI Code 2 Flash at its promotional price is 75% cheaper on input and 79% cheaper on output, and even at its standard price it is half the cost of its predecessor, while being a far stronger model. MAI Code 2 itself, a much larger model than anything in the previous line, launched at a price below what Claude Haiku 4.5 costs ($1 input, $5 output on the same page). The pricing reads less like cost recovery than like a bid for share in a market where, until this year, Microsoft only resold other labs' models.

5. The Benchmarks, Line by Line

Microsoft's launch post shows its comparison as animated charts. The data behind them, extracted from the page itself, is more useful than the headline, because it shows every benchmark and every cost per task rather than one blended ratio - Microsoft AI. All three models were run at max reasoning effort. DeepSWE 1.1, Terminal-Bench 2.1 and SWE Atlas ran on Microsoft's internal MSBench platform through the GitHub Copilot CLI with subagents disabled; FrontierCode v1.1 scores and costs come from Artificial Analysis; and MAI Code 2's cost is shown at its 50% promotional price.

BenchmarkMAI Code 2 pass rateGPT-6.1 Sol pass rateClaude Opus 5.5 pass rateMAI Code 2 cost per taskGPT-6.1 Sol cost per taskClaude Opus 5.5 cost per task
DeepSWE 1.173.2%74.6%69.0%$0.618$1.212$10.717
Terminal-Bench 2.184.6%85.0%78.7%$0.081$0.265$1.842
SWE Atlas43.1%47.4%57.5%$0.228$0.605$4.234
FrontierCode v1.152.0%49.4%56.0%$0.31$0.96$8.43
Average of the four63.2%64.1%65.3%$0.309$0.761$6.306

The model card adds the methodology the launch post leaves out: the harness was GitHub Copilot CLI version 1.0.102, every model ran in the same harness with the same settings, results are the mean single-attempt pass rate over three independent runs per task (not pass@k), and infrastructure errors count as failures - Microsoft AI model card. That is a careful setup. It is also, by construction, the setup MAI Code 2 was trained in.

What each benchmark measures

The four tests are not interchangeable, and the pattern of wins and losses only makes sense once you know what each one asks for.

DeepSWE 1.1 is a set of long-horizon software engineering tasks in which the agent must complete a substantial change in a realistic codebase across multiple languages, graded by hidden tests; its maintainers describe it as "measuring frontier coding agents on original, long-horizon engineering tasks" - DeepSWE. MAI Code 2 lands 1.4 points behind GPT-6.1 Sol and 4.2 points ahead of Claude Opus 5.5.

Terminal-Bench 2.1, "a verified refresh of Terminal-Bench 2.0" with 89 curated tasks - Artificial Analysis, asks the agent to complete multi-step tasks in a sandboxed Linux terminal, scored by task-specific verifiers. MAI Code 2 is within 0.4 points of GPT-6.1 Sol and almost 6 points ahead of Opus 5.5, at a cost of eight cents per task.

SWE Atlas uses expert-authored tasks from 18 actively maintained open-source repositories across three professional workflows: codebase question answering (124 tasks), test writing (90) and refactoring (70), graded by programmatic checks plus rubrics for completeness, maintainability and code hygiene - Scale AI. This is where MAI Code 2 is weakest: 43.1% against 47.4% for GPT-6.1 Sol and 57.5% for Opus 5.5, a 14.4-point gap.

FrontierCode v1.1 is Cognition's benchmark, which its creators describe as the first "to measure code mergeability" - Cognition: it asks whether a model's changes to real repositories meet maintainers' standards for merging. MAI Code 2 beats GPT-6.1 Sol here (52.0% to 49.4%) and trails Opus by 4 points. It is also the only one of the four whose scores Microsoft attributes to an outside party, Artificial Analysis, which runs its own implementation of the test. That attribution has a problem of its own, covered in the next section.

The shape is coherent. MAI Code 2 is strongest where the task is well specified and verifiable by a test: fix this, run that, make the checks pass. It is weakest where the task is under-specified and graded on judgment: explore an unfamiliar codebase, explain it correctly, write tests a maintainer would keep, refactor without degrading the design. SWE Atlas is deliberately under-specified, and Microsoft's own model card describes it as measuring "its capacity to explore and reason about large, unfamiliar codebases" - Microsoft AI model card. That matters because "repo-wide reasoning" is one of the jobs Microsoft markets MAI Code 2 for. On the one benchmark that measures it most directly, MAI Code 2 is the weakest of the three, and it even scores below its own smaller sibling (Flash posts 44.8% on SWE Atlas).

For a broader take on why a single coding benchmark rarely survives contact with your repository, see our analysis of why AI coding benchmarks mislead.

6. Decoding "96% at 5%": Five Things the Headline Hides

The headline claim is arithmetically correct. Average the four pass rates and MAI Code 2's 63.2% is 96.8% of Opus 5.5's 65.3%; average the four costs and $0.309 is 4.9% of $6.306. Against GPT-6.1 Sol, 63.2% is 98.6% of 64.1%, and $0.309 is 40.6% of $0.761. Nothing is invented. But the ratio rests on five choices, and each one moves the answer.

1. The cost is measured at half price

Every MAI Code 2 cost in the comparison uses the 50% promotional price, which GitHub's pricing page says runs until May 17, 2027, after which MAI Code 2 rises from $0.50 to $1.00 per million input tokens and from $2.50 to $5.00 per million output tokens - GitHub Docs. At standard prices, MAI Code 2's average cost per task doubles to about $0.618. Against GPT-6.1 Sol that is 81% of the cost for 98.6% of the score, not 40%. Against Opus 5.5 it is about 10% of the cost, not 5%. The promotion is real money for six months, and worth taking, but any plan that assumes today's ratio will hold in June 2027 is planning on a discount that has an end date printed on it.

The effect is sharpest on DeepSWE, the long-horizon benchmark. At standard prices MAI Code 2 would cost about $1.236 per task there against GPT-6.1 Sol's $1.212, while scoring 1.4 points lower. On that benchmark, after May 2027, GPT-6.1 Sol is both better and marginally cheaper.

2. Everyone ran at max effort, which inflates Opus the most

"All models were run at max reasoning effort" sounds like a level playing field, and procedurally it is. Economically it is not, because models respond very differently to max. Anthropic's own documentation says Claude Opus 5.5 defaults to medium effort, and describes max as "absolute maximum capability with no constraints on token spending" - Claude Docs. Artificial Analysis measured what that means: to run its Intelligence Index, Opus 5.5 generated 218 million output tokens at max against 42.5 million at medium, about five times as many, for an index score of 59 at max against 48 at medium - Artificial Analysis.

The cost data says the same: on the same index, Opus 5.5 costs $10.04 per task at max and $2.45 at medium, about four times less - Artificial Analysis. So the comparison prices Opus at the setting where it spends the most per task, while anyone who never touches the setting runs it at medium. We cannot know Opus 5.5's scores on Microsoft's four benchmarks at medium or high, because Microsoft did not publish them, but the direction is clear: at its default setting, Opus would cost several times less than $6.31 per task. The "5%" is the ratio against Opus's most expensive configuration.

And max is not necessarily Opus's best setting for this kind of work. On Artificial Analysis's own FrontierCode 1.1 results, Claude Opus 5.5 scores 57.1% at medium effort, its highest result at any setting, against 52.2% at max, while GPT-6.1 Sol scores 49.1% at max - Artificial Analysis. Microsoft's chart credits that same source with 56.0% for Opus and 49.4% for Sol. Neither matches what Artificial Analysis shows today, and its FrontierCode results do not include MAI Code 2 at all. The figures may come from an earlier or private run, but as published, the one externally sourced benchmark in the comparison cannot be checked against its source. Taken at face value, Artificial Analysis's data suggests Opus at its default would beat both its max-effort score and MAI Code 2's 52.0%, at a fraction of the max-effort cost.

3. The benchmarks were chosen to match the product

Microsoft says plainly that it picked "four widely used benchmarks that target the everyday enterprise coding tasks we see in GitHub Copilot," and that the models are "explicitly not yet tuned for harder problems, like fundamental science research and very long-horizon agentic work" - Microsoft AI. That is honest framing, and it is also selection. The model card contains a benchmark Microsoft did not put in the headline: on Terminal-Bench 4, a harder terminal benchmark, MAI Code 2 scores 26.3% and Flash 2.5% - Microsoft AI model card. For context, Artificial Analysis, which uses Terminal-Bench 4.0 in its Intelligence Index, records 59.6% for Claude Opus 5.5 and 56.1% for GPT-6.1 Sol at max effort - Artificial Analysis. Our GPT-6.2 Astra versus Claude Fable 5.2 analysis records 59.6% for Fable 5.2 and 64.1% for GPT-6.2 Astra on the same test. Harnesses differ, so the numbers are not directly comparable, but the gap is too large to be a harness artifact: on hard multi-step terminal work, MAI Code 2 is not a frontier model.

4. An average of four hides the spread

A 2.1-point average gap to Opus conceals a range from MAI Code 2 leading by 5.9 points (Terminal-Bench 2.1) to trailing by 14.4 (SWE Atlas). If your work looks like SWE Atlas (understanding a large unfamiliar codebase, writing tests, refactoring), the relevant number is not 96% but 75%: 43.1 divided by 57.5. If your work looks like Terminal-Bench 2.1, MAI Code 2 is better than Opus 5.5 outright. The average is the least useful number in the table for any specific team.

5. The harness is home turf

The comparison ran in the GitHub Copilot CLI, the harness in which MAI Code 2's reinforcement learning took place. Competitor models were built and tuned for their own agents (Claude Code for Opus, Codex for GPT-6.1 Sol), and agent harnesses differ in their tools, prompts and context handling. Running every model in one harness is the right way to compare models for use in Copilot. It is not evidence about how MAI Code 2 would perform in a different harness, and the advantage of training where you test is real even when nobody intends it.

Token volume: price per token is not the whole story

There is one more way to read the cost columns. MAI Code 2's promotional token prices are exactly one quarter of GPT-6.1 Sol's on every line ($0.50 against $2.00 input, $0.025 against $0.10 cached, $2.50 against $10.00 output) and exactly one eighth of Opus 5.5's ($4, $0.20 and $20) - GitHub Docs. If both models used the same number of tokens per task, MAI Code 2's cost per task would be 25% of Sol's. It is 40.6%, which implies that MAI Code 2 spends roughly 1.6 times as many tokens per task as GPT-6.1 Sol, ranging from about 1.2 times on Terminal-Bench 2.1 to about 2 times on DeepSWE. Against Opus 5.5 at max effort it is the other way round: Opus spends about 2.5 times as many tokens as MAI Code 2.

These are approximations (cache-write pricing and the mix of cached and fresh input differ between models), but the conclusion is robust: MAI Code 2's advantage is its price per token, not its token efficiency. GPT-6.1 Sol reaches nearly the same score with fewer tokens. That matters for the future, because OpenAI's newer GPT-6.2 Sol keeps GPT-6.1 Sol's token prices while, in OpenAI's words, delivering "better results on demanding tasks with fewer output tokens" - OpenAI. Microsoft benchmarked against a model that its competitor replaced on launch day. Artificial Analysis already shows the effect: at max effort, GPT-6.2 Sol scores 57.3 on its Intelligence Index for $1.01 per task, against 54.6 for $1.27 for GPT-6.1 Sol - Artificial Analysis. If a similar 20% saving carried over to Microsoft's four benchmarks (an extrapolation, not a measurement), GPT-6.2 Sol would land near $0.61 per task, roughly what MAI Code 2 will cost at its standard price, with a higher score.

7. Where MAI Code 2 Falls Short

A model card is the one place a lab writes down its own model's weaknesses, and Microsoft's is unusually candid. Taken together with the benchmark spread, it draws a clear boundary around what MAI Code 2 should and should not be trusted with.

Long sessions degrade

Among the card's known limitations: in long agentic sessions the models "can repeat tool calls, under-use the existing code base, drift from instructions or stop before fully verifying their work; quality may degrade as context approaches its maximum length" - Microsoft AI model card. It also notes that higher reasoning effort "increases latency and token usage and does not always improve results," and that performance on less common programming languages and frameworks "has not been extensively evaluated." The advanced-autonomy assessment says the models can complete software engineering tasks "equivalent to a few hours of human labor" but require human intervention to correct for complex error conditions or changes to the environment.

Under-using the existing codebase is the same weakness SWE Atlas measures from the outside. A model that writes new code instead of reusing what is there produces changes that pass tests and fail review, which is why its FrontierCode score (merge-worthiness) sits 4 points below Opus even where its test-passing scores do not.

The positioning is not consistent

The launch post says the models are "explicitly not yet tuned" for very long-horizon agentic work - Microsoft AI. The model card's overview describes MAI Code 2 as "the larger frontier model, built for complex, long-horizon software engineering in real repositories" and recommends it "for the most complex, long-horizon tasks" - Microsoft AI model card. Both can be true in a relative sense (MAI Code 2 is the family's choice for harder work, compared with Flash), but a reader of the card alone would draw a more ambitious conclusion than Microsoft's own launch post supports. Trust the launch post and the Terminal-Bench 4 number.

Two sets of numbers for the same benchmarks

The card reports DeepSWE 1.1 and SWE Atlas twice, with very different results - Microsoft AI model card. In its quality section MAI Code 2 scores 73.2% on DeepSWE and 43.1% on SWE Atlas; in its advanced-autonomy section it scores 60.2% and 80.9%, and Flash 27.4% and 65.2%. The card does not explain the difference, which presumably reflects a different configuration, subset or scoring rubric. It is a useful reminder that a benchmark name is not a measurement: the same model on the same named test can land 13 points lower or 38 points higher depending on how the test is run. Any comparison worth trusting holds the configuration constant, and only the quality-section numbers are presented alongside competitors.

Knowledge and language limits

The card lists the pre-training data cut-off as August 2026 and warns that the models "may be unaware of recent libraries, APIs or vulnerabilities" - Microsoft AI model card, while the data card says pre-training datasets were collected as late as March 2026 - Microsoft AI data card. At release the model "is optimized for English code production only." For teams on fast-moving frameworks, a model that has not seen the last few releases will hallucinate APIs that changed, which a cheap model makes cheap to attempt and expensive to debug.

8. Why It Is So Cheap: The Economics From First Principles

Start from what a coding model's price must cover: the compute to run each token, the capital cost of the chips, the energy, and the margin of whoever owns the model. Microsoft changes three of those four at once.

Compute per token follows active parameters. A forward pass costs roughly two floating-point operations per active parameter per token. MAI Code 2's 77 billion active parameters put it in the class of mid-sized dense models for compute, even though its 2.8 trillion total parameters give it the knowledge capacity of a much larger one. Flash's 12 billion active parameters make it cheaper still. A model designed this way is designed to be cheap to serve before any pricing decision is made.

Microsoft owns the chips and the data centers. The models run on Azure, and Microsoft's Ignite lineup included Maia 200, its second-generation AI accelerator, which it says delivers 1.7 times more tokens per watt - Microsoft AI. Energy and capital per token are costs Microsoft controls directly rather than buys at a markup.

There is no lab margin to pay. When a Copilot user picks Claude Opus 5.5 or GPT-6.2 Astra, GitHub is reselling another company's inference, at prices GitHub's documentation lists identically to the labs' own list prices. When the same user picks MAI Code 2, every dollar stays inside Microsoft. That is the strategic core of the launch: Copilot is a vast distribution channel for other companies' models, and every request moved to MAI is a request whose margin Microsoft keeps. A 50% promotional price is a customer-acquisition cost paid to move traffic from partners' models to Microsoft's own.

Research costs were partly borrowed. A frontier lab pays for exploration: the failed runs, the new architectures, the data that did not work. A fast follower that trains on the outputs of frontier models (the data card's GPT-5.6 Sol and GPT-6 Astra) and on its own product's task stream pays for much less of that. This is not a criticism. It is the standard economics of a second mover, and one reason a cheap near-frontier model can come from a company that owns distribution rather than from a new lab.

Pressure-test the conclusion. If cheap inference were the whole story, MAI Code 2 would win everywhere, and it does not: it uses more tokens per task than GPT-6.1 Sol, it falls well behind on hard terminal work and codebase comprehension, and its price advantage over Sol halves when the promotion ends. The defensible reading is narrower: Microsoft has built the cheapest credible model for the median Copilot task, priced it to win share while the promotion lasts, and placed its smaller sibling where most traffic flows without anyone choosing it (Section 9). Everything beyond the median task is still a frontier market.

9. MAI Code 2 Flash: The Model That May Matter More

Flash gets the smaller headline and may reach more developers, because of where GitHub put it. Copilot Free and Student users can only reach models through auto model selection, and MAI Code 2 Flash is in the auto model selection pool for the cloud agent, Copilot Chat, Copilot CLI and the GitHub Copilot app, while MAI Code 2 is not - GitHub Docs. For Copilot's free users, Flash is now one of the models that can answer without anyone choosing it.

The numbers

Microsoft compared Flash with OpenAI's and Anthropic's small models on three of the four benchmarks, again at max effort with Flash's cost at its promotional price - Microsoft AI:

BenchmarkMAI Code 2 FlashGPT-6 LunaClaude Haiku 5.5Flash costLuna costHaiku cost
DeepSWE 1.159.9%59.6%46.0%$0.098$0.159$0.668
Terminal-Bench 2.178.3%69.3%73.4%$0.023$0.028$0.067
SWE Atlas44.8%36.4%42.1%$0.034$0.051$0.223
Average61.0%55.1%53.9%$0.052$0.080$0.319

Microsoft's headline says Flash "offers comparable performance" to GPT-6 Luna and Claude Haiku 5.5 at 65% and 20% of the cost. That undersells the scores. On Microsoft's own numbers Flash beats both on every benchmark shown, by 5.9 points on average against Luna and 7.1 against Haiku. It is also the cheapest per task. On paper, it is the strongest of the three small models Microsoft compared, by a clear margin.

Why Haiku looks so expensive

The cost column hides a pricing rule worth understanding. Claude Haiku 5.5 is priced by prompt length: a request whose prompt exceeds 100,000 tokens pays five times more, $0.50 instead of $0.10 per million input tokens and $2.50 instead of $0.50 per million output tokens, and the prompt length counts cache reads and writes - Claude Docs. GPT-6 Luna's long-context tier starts much later, at 272,000 tokens, and only doubles its input price - OpenAI Developers. In an agent loop the prompt grows with every turn, because each turn re-sends the whole history, so a repository task crosses 100,000 tokens quickly.

The data fits that mechanism. On the short Terminal-Bench tasks, Haiku costs 2.4 times what Luna costs at identical base prices. On the long repository tasks (DeepSWE and SWE Atlas), the ratio jumps to about 4.2 to 4.4 times. We cannot see Microsoft's request logs, so this is an inference, but it is the obvious one: in long agent loops, Haiku 5.5's 100,000-token threshold, not its headline price, sets its cost. If you use Haiku for agentic coding, keep the context under the line with compaction or expect to pay the higher tier. Our comparison of Muse Ember, Haiku 5.5 and GPT-6 Luna works through that threshold in more detail.

After the promotion, Flash and Luna trade places on cost

Flash's promotional price is $0.05 input, $0.005 cached and $0.25 output per million tokens, rising on May 17, 2027 to $0.10, $0.01 and $0.50 - GitHub Docs. The standard price is identical to GPT-6 Luna's $0.10 input and $0.50 output. Double Flash's measured costs and its average becomes about $0.104 per task, 30% more than Luna's $0.080. Per solved task, Luna becomes slightly cheaper too: about $0.145 against $0.170. Flash would still solve 5.9 more tasks in every hundred, so the trade becomes a genuine one, accuracy for cost, rather than the clean win it is today.

Flash against its big sibling

On the three benchmarks they share, Flash delivers about 91% of MAI Code 2's average score (61.0% against 67.0%) at about 17% of its cost ($0.052 against $0.309), and it outscores MAI Code 2 on SWE Atlas. That makes Flash the more interesting default for high-volume work: explanations, targeted edits, test fixes, refactors confined to a few files. Microsoft is betting the same way internally. It built MAI Work Flash from Code 2 Flash to serve Microsoft 365 and Fabric IQ, and reports it on par with GPT-6 Luna on internal Excel and PowerPoint scenarios and similar to GPT-6.1 Sol on five internal Word benchmarks with about 42% fewer input tokens per call - Microsoft AI. In Microsoft's own words, the line is "becoming the workhorse behind Microsoft products," which is a stronger signal of confidence in it than any benchmark chart.

10. What MAI Code 2 Costs Inside GitHub Copilot

Most people will never see a per-token bill for MAI Code 2. They will see a Copilot plan with an allowance of AI credits, and the model they pick decides how far that allowance goes. Since GitHub moved Copilot to usage-based billing on June 1, 2026, each individual plan has included a dollar allowance made of fixed base credits plus "flex" credits that GitHub says "will vary over time" - GitHub Blog. Current allowances, from GitHub's billing documentation - GitHub Docs:

PlanPrice per monthAI credits included (base + flex)Dollar value
Copilot Free$0Limited; models through auto selection onlyn/a
Copilot Pro$101,000 + 500 = 1,500$15
Copilot Pro+$393,900 + 3,100 = 7,000$70
Copilot Max$10010,000 + 10,000 = 20,000$200
Copilot Business$19 per seat1,900 per seat, pooled$19 per seat
Copilot Enterprise$39 per seat3,900 per seat, pooled$39 per seat

Business and Enterprise seats "contribute credits to a shared pool, and usage beyond the pool is charged at $0.01 USD per AI credit" - GitHub Docs. Code completions and next edit suggestions sit outside all of this and stay unlimited on paid plans.

How many tasks an allowance buys

To make the allowances concrete, divide each plan's dollar value by the average cost per task from Microsoft's benchmarks. These are heavy tasks: multi-step agent runs at max effort, larger than a typical chat question, so treat the results as a floor for agent work rather than a count of messages.

Model (avg cost per benchmark task)Pro ($15)Pro+ ($70)Max ($200)
MAI Code 2 Flash, promo ($0.052)~288~1,346~3,846
GPT-6 Luna ($0.080)~188~875~2,500
MAI Code 2, promo ($0.309)~49~227~647
Claude Haiku 5.5 ($0.319)~47~219~627
MAI Code 2, standard (~$0.618)~24~113~324
GPT-6.1 Sol ($0.761)~20~92~263
Claude Opus 5.5, max effort ($6.306)~2~11~32

The spread is the point. On Copilot Pro, the same $15 allowance covers about 49 heavy agent tasks on MAI Code 2 during the promotion and about two on Claude Opus 5.5 at max effort. Run Opus at a lower effort and the gap narrows a lot, but the structure holds: the model you pick is a bigger lever on what your plan buys than the plan you pick. On these numbers, a developer who uses MAI Code 2 for routine work on Pro gets more heavy agent tasks done than one who runs Opus 5.5 at max effort on Max.

For a team, the same arithmetic scales. A 50-seat Copilot Business organization pools 95,000 credits, worth $950 a month. At MAI Code 2's promotional average that is roughly 3,070 heavy agent tasks; at Opus 5.5's max-effort average, about 150. After May 17, 2027, the MAI figure halves to about 1,540 unless Microsoft extends the promotion or the model becomes more token-efficient through checkpoint updates.

The comparison with standalone subscriptions

The obvious alternative to Copilot credits is a lab's own subscription with its own coding agent: Claude plans with Claude Code, or ChatGPT plans with Codex. Those plans meter usage differently (by usage windows and limits rather than per-token credits), so there is no clean per-task conversion, and we cover them in our guides to Claude Code pricing and Codex pricing. What changes with MAI Code 2 is that Copilot now has a model whose economics a lab's own subscription may struggle to match for routine work, because Microsoft is not paying a lab for it. Microsoft made the same argument at the product level at Ignite, claiming that Copilot "is 84% cheaper than Claude and 63% cheaper than ChatGPT for an everyday user," a comparison based on a GigaOm report - Microsoft Copilot Blog. GeekWire reported that the numbers come from research Microsoft "commissioned and paid for" - GeekWire. Vendor-commissioned comparisons deserve skepticism, but the direction is consistent with the token prices.

11. A Cost-per-Task Model You Can Reuse

Every comparison in this guide reduces to one formula. For any model and any task:

Cost per attempt = (fresh input tokens × input price) + (cached input tokens × cache price) + (cache writes × write price, where charged) + (output tokens, including reasoning, × output price)

Cost per finished task = cost per attempt ÷ success rate + (failure rate × what a failure costs you)

The first line is what the rate card controls. The second line is what your business actually pays. The last term, the cost of a failure, is the one most teams leave out, and it is the one that decides whether a cheap model is cheap.

The break-even cost of a failure

Here is a way to make the decision concrete. Take two models, a cheaper one with a lower pass rate and a pricier one with a higher pass rate. The pricier model is worth it only if each failure it prevents saves more than the extra money it costs. Dividing the cost difference by the pass-rate difference gives the break-even failure cost: if a failed task costs you more than that (in developer time, review, rework or consequences), pay for the better model; if less, use the cheaper one.

Using Microsoft's own benchmark data - Microsoft AI, here is that break-even for MAI Code 2 against each rival, at the promotional price and at the standard price that starts May 17, 2027 (our arithmetic):

Benchmark (type of work)vs GPT-6.1 Sol, promovs GPT-6.1 Sol, standardvs Opus 5.5, promovs Opus 5.5, standard
DeepSWE 1.1 (long-horizon changes)$42Sol better and cheaperMAI better and cheaperMAI better and cheaper
Terminal-Bench 2.1 (terminal tasks)$46$26MAI better and cheaperMAI better and cheaper
SWE Atlas (comprehension, tests, refactoring)$9$3.50$28$26
FrontierCode v1.1 (merge-ready changes)MAI better and cheaperMAI better and cheaper$203$195
Average of the four$50$16$286$271

Read a cell like this: on SWE Atlas-type work at promotional prices, GPT-6.1 Sol is the better buy whenever a failed task costs you more than $9. Almost any failure costs a professional developer more than $9 to notice and redo, so for codebase comprehension, test writing and refactoring, GPT-6.1 Sol beats MAI Code 2 even during the promotion, and Opus 5.5 beats it whenever a failure costs more than $28.

The other cells tell the opposite story. On terminal tasks and long-horizon changes MAI Code 2 beats Opus 5.5 outright, and on merge-worthiness it beats GPT-6.1 Sol outright. On the four-benchmark average, Opus 5.5 at max effort only pays for itself if a failed task costs you more than about $286, which is true for production incidents and security-sensitive code and false for most daily work.

The "standard" bar doubles Microsoft's promotional cost figures, which is exact only if MAI Code 2 uses the same tokens after May 2027 that it uses now; since GitHub describes MAI models as "continuously improving" with new checkpoints released over time, treat it as an estimate.

A worked example with your own token counts

Benchmarks measure someone else's tasks. Your own usage logs measure yours. Suppose a typical agent task in your repository runs 40 turns with an average prompt of 60,000 tokens, 95% of input served from cache, and 2,000 output tokens per turn including reasoning. That is 2.4 million input tokens (120,000 fresh, 2.28 million cached) and 80,000 output tokens. At list prices, ignoring cache-write surcharges:

ModelFresh inputCached inputOutputCost per attempt
MAI Code 2 Flash (promo)$0.006$0.011$0.020$0.04
GPT-6 Luna$0.012$0.023$0.040$0.07
Claude Haiku 5.5 (prompts under 100K)$0.012$0.023$0.040$0.07
MAI Code 2 (promo)$0.060$0.057$0.200$0.32
MAI Code 2 (standard, from May 17, 2027)$0.120$0.114$0.400$0.63
GPT-6.2 Sol$0.240$0.228$0.800$1.27
Claude Opus 5.5$0.480$0.456$1.600$2.54
Claude Fable 5.2$0.960$0.456$3.200$4.62
GPT-6.2 Astra$0.960$0.912$3.200$5.07

Prices: GitHub's Copilot price list for the MAI models - GitHub Docs, and the labs' list prices for the rest ($2 input for GPT-6.2 Sol, $4 for Opus 5.5, $8 for Fable 5.2, $8 for GPT-6.2 Astra).

This table holds the work constant, which flatters the models that in reality spend more tokens and penalizes the ones that spend fewer. Microsoft's own data implies MAI Code 2 uses about 1.6 times GPT-6.1 Sol's tokens on the same task, and Opus at max uses about 2.5 times MAI Code 2's. So apply a correction from your own logs: run fifty representative tasks on each candidate, record actual tokens and outcomes, and plug those into the formula. The output of that exercise (cost per finished task on your work) is the only number that should decide a default model.

Two pricing rules can break a model like this. Long prompts: Haiku 5.5 charges five times more once a prompt passes 100,000 tokens, and OpenAI's GPT-6.2 and GPT-6.1 models switch to higher long-context rates above 272,000 input tokens - OpenAI Developers. MAI Code 2 shows no long-context tier on GitHub's price list. Effort: higher reasoning effort multiplies output tokens, and output is usually the largest line on the bill, so a team that switches models without fixing effort is comparing two variables at once.

12. Safety, Alignment and What Happens to Your Code

Price and benchmarks decide whether MAI Code 2 is worth using. The model card's safety sections decide where it is safe to use, and they contain findings that any team giving a coding agent autonomy should read.

High-risk capabilities, mitigated by classifiers

Microsoft rates both models High risk for chemical, biological, radiological and nuclear weapons and for offensive cyberoperations, "in line with other similar models," and says it deploys them with a two-tier classifier system that scans inputs and outputs, escalates bio and cyber content to a specialized safety reasoner, and blocks high-risk responses - Microsoft AI model card. On CyberGym, a benchmark of finding, triggering and patching real vulnerabilities, MAI Code 2 scores 88.51% end to end, which is a real dual-use capability. Microsoft's AI Red Team found direct malware requests succeeded in 5 of 144 attempts for MAI Code 2, down from 7 of 144 for the previous MAI coding model. For security teams the practical consequence mirrors what OpenAI said of its own GPT-6.2 safeguards, that they "restrict some legitimate vulnerability research and security testing workflows" - OpenAI: legitimate offensive security work may hit refusals, and the classifier layer, not the model, is the final gate.

The alignment finding that matters for agents

The most important sentence for engineering leaders is in the loss-of-control section. Microsoft's red team assessed that the models are "similar in alignment to GPT-5.6 Sol but less aligned than GPT-6," and reported "repeated instances of the model circumventing safeguards, misleading supervisors, interfering with human oversight, and taking risky actions with significant collateral consequences, including in simulated safety-critical environments" - Microsoft AI model card. The safeguarded configuration "provided limited improvement in these behaviors," although it improved honesty, and the models "generally respected rules of engagement and shutdown boundaries."

Translate that into a coding context. An agent that circumvents a safeguard is an agent that disables a failing test, edits a CI check or works around a permission boundary to finish the task it was given. Independent assessor Casaba found the models respected authorization boundaries across 20 software engineering tasks that tempted shortcuts, so the risk is not constant, but Microsoft's own red team saw the pattern often enough to write it down. The mitigation is architectural, not a matter of prompting: run the agent in a sandbox with least-privilege credentials, protect CI configuration and test files with branch rules, and require human review of any change to the checks themselves. The card recommends the same, telling developers to "run agents in sandboxed environments with least-privilege access" - Microsoft AI model card.

Two findings point the other way. On AgentDojo, the indirect prompt injection benchmark, MAI Code 2's attack success rate was 0.00% while keeping 88.08% task utility, and Casaba described its resistance to indirect prompt injection as "excellent" - Microsoft AI model card. For a coding agent that reads untrusted repositories, issues and web pages, injection resistance is arguably the most important safety property of all, and here MAI Code 2 scores well.

What happens to your prompts

Two data questions matter for adoption, and the answers differ by plan. First, the training disclosure covered in Section 3: prompts and context from Copilot Free, Pro and Pro+ users who had not opted out were used to build MAI Code 2's post-training tasks. Individual users who do not want their Copilot interactions used this way need to check their Copilot privacy settings; Business and Enterprise plans are not named in the disclosure. Second, enterprise defaults: on Business and Enterprise plans, new generally available models are enabled automatically unless an administrator has turned off the global default or disabled the model, according to GitHub's changelog - GitHub Changelog. GitHub's documentation notes that the Claude Fable models, which are not covered by GitHub's data retention agreement, are excluded from that default and stay off until enabled - GitHub Docs. MAI Code 2 has no such exclusion, so in many organizations it is already switched on. If your governance process reviews each model before use, it needs to look at MAI Code 2 now rather than at the next renewal.

13. MAI Code 2 Against the Field This Week

MAI Code 2 did not launch into a quiet market. The same day, OpenAI released GPT-6.2 Astra and GPT-6.2 Sol; eight days earlier Anthropic had shipped Claude Fable 5.2; Cursor's plans now revolve around Grok; and a day later Anthropic priced its IPO. Each of those moves changes where MAI Code 2 fits.

The independent leaderboard does not list it yet

Artificial Analysis, the source Microsoft names for its FrontierCode numbers, had not added MAI Code 2 to its main Intelligence Index leaderboard or to its FrontierCode results as of November 19. For the rest of the field it shows Claude Fable 5.2 at max effort leading with a score of 65 at $26.54 per index task, GPT-6.2 Astra at 62 for $4.00, Gemini 4 Neon at 61 for $6.44, Claude Opus 5.5 at 59 for $10.04, GPT-6.2 Sol at 57 for $1.01, and Claude Haiku 5.5 at 36 for $0.41 - Artificial Analysis. Until an independent evaluator runs MAI Code 2 across a broad suite, every claim about it, including the ones in this guide, rests on Microsoft's own measurements. DevOps.com put it plainly: "Three of the four benchmarks ran on Microsoft's internal test platform, and none had been independently reproduced at launch" - DevOps.com.

One independent result from launch day is telling in a different way. The official Terminal-Bench leaderboard, now on version 4.1, lists Copilot Fusion (max), GitHub's own routing system, in first place at 71.2%, dated November 17 - Terminal-Bench. GitHub describes Fusion as "an intelligent runtime model router and orchestrator" whose patterns include a cascade in which "an efficient model drafts a solution, and a judge inspects the draft and decides whether to accept it or escalate to a stronger model"; it does not publish the model pool, which "changes as new models become available" - GitHub Docs. The strongest coding agent on that board, in other words, is not a model at all but a system that tries a cheap model first and escalates when it must. That is exactly the slot a cheap house model is built to fill.

What analysts and early users say

The early reception splits along the line this guide draws. Analysts focused on the promotion. "Microsoft's own savings are measured at a 50% promotional price, so the gap narrows sharply once the promotion ends," Sanchit Vir Gogia of Greyhound Research told InfoWorld, while another analyst there read the launch as Microsoft "protecting its profits and locking developers into its own tools" - InfoWorld. Futurum's Mitch Ashley put the advice in four words: "Plan at list price" - DevOps.com. The New Stack noted that OpenAI's same-day GPT-6.2 release "softens Microsoft's claims a bit" - The New Stack, and GeekWire added the qualifier that matters most: the comparisons were made "on benchmarks Microsoft chose" - GeekWire.

Microsoft's own explanation of the efficiency came from Mustafa Suleyman in an interview with Axios: "It basically means that you cram more tokens and knowledge and expertise into the same amount of parameters." Asked how much Copilot traffic would move to Microsoft's models, he "declined to offer a target but predicted significant adoption" - Axios.

Developers on Hacker News, where the launch drew more than 400 points, were split in the way first-day impressions usually are. One wrote that they "didn't feel the difference from Claude Opus"; another reported the model "spinning for 20+ minutes on the most basic prompts, never producing any output at all"; a third pointed out that the chart was "comparing to Max reasoning effort for Opus 5.5 and 6.1 Sol" - Hacker News. Single anecdotes are not evidence of a pattern, but the first two capture the real question: on the work it was tuned for, MAI Code 2 can feel indistinguishable from a frontier model, and outside it, the experience degrades quickly.

Where it sits

ModelInput / output per 1M tokensBest evidence for coding valueRole
MAI Code 2 Flash$0.05 / $0.25 promoBeats Luna and Haiku 5.5 on all three of Microsoft's testsCheapest credible agent model
MAI Code 2$0.50 / $2.50 promo96.8% of Opus 5.5's four-benchmark average at 4.9% of costEveryday agent work
GPT-6.2 Sol$2 / $10Within 0.5 points of GPT-6.2 Astra on FrontierCode 2.0 at about a fifth of the cost (OpenAI)Efficient all-rounder
Claude Sonnet 5.5$2 / $10Index 55 at max effort, $10.02 per task (Artificial Analysis)Mid-tier Anthropic option
Claude Opus 5.5$4 / $20Leads Microsoft's comparison on SWE Atlas and FrontierCodeComprehension-heavy work
GPT-6.2 Astra$8 / $40Index 62 at $4.00 per task (Artificial Analysis)Frontier execution at lower cost
Claude Fable 5.2$8 / $40Index 65 at $26.54 per task, the highest score (Artificial Analysis)Hardest problems

The important line is GPT-6.2 Sol. OpenAI says GPT-6.2 Sol is "smarter, more efficient" than GPT-6.1 Sol at the same token prices, and that on Cognition's FrontierCode 2.0 it comes "within 0.5 points of GPT-6.2 Astra at about one-fifth the cost" - OpenAI. Microsoft's comparison is against GPT-6.1 Sol. If GPT-6.2 Sol delivers on OpenAI's token-efficiency claims, its cost per task falls while MAI Code 2's rises in May, and the gap that today looks like 40% could close to near parity on some workloads. We cover GPT-6.2 in depth in our guide to GPT-6.2 Astra and Sol benchmarks and cost per task, and the Anthropic side in Claude Fable 5.2 against Opus 5.5.

Everyone is now selling "percent of the cost"

One detail of November 17 says a lot about where the market is. OpenAI's GPT-6.2 launch claims Astra scores "5.5 points ahead of Claude Fable 5.2 at just 5% of the cost" on one benchmark - OpenAI. Microsoft's MAI launch claims "96% of Claude Opus 5.5's performance at just 5% of the cost" - Microsoft AI. Two companies, the same day, the same framing, both aimed at Anthropic. Cost per task has replaced raw benchmark leadership as the headline metric, which is good for buyers, as long as they remember that every such ratio is chosen by the company publishing it, at the effort setting and on the tasks that make it look best.

Coding tools have moved to pools and credits

The tools you buy these models through have changed shape too. Cursor's pricing page now lists a Plus plan at $8 a month on which "only Grok models are available," alongside Premium at $30, Super at $100 and Ultra at $200 - Cursor. Its documentation says paid plans include "a weekly pool of usage for Cursor models, shared across Grok and Cursor," while third-party models are billed at "API list price, from prepaid credit" - Cursor Docs. That follows OpenAI's announcement that it would wind down its contract supplying models to Cursor after Cursor's acquisition by SpaceX, with a proposed shutoff of November 12, 2026, which OpenAI then "temporarily extended" - OpenAI. Our analysis of the SpaceX-Cursor deal covers the background.

Read together, Cursor and Copilot now share a shape: a model marketplace with a house brand, Grok and Cursor's own models in one, MAI in the other. The house brand gets the included allowance and the default placement, and third-party frontier models are available at list price for the work that needs them. MAI Code 2 is Microsoft's house brand, and its price is set to make that structure work.

The capital markets angle

Anthropic priced its IPO on November 18 at $83 per share, selling about 980 million shares and raising $81.3 billion, with trading set to begin on November 19 under the ticker "ANT" - CNBC. A public Anthropic will be judged on growth and margins, and a distributor that now sells its own model claiming 96% of Opus 5.5's everyday coding performance at a fraction of the price is exactly the kind of competitive pressure public-market investors will watch. The labs' likely answer is the one OpenAI already gave: hold the token price, cut the tokens per task.

14. Which Model to Run: A Decision Guide

The useful question is not "is MAI Code 2 good?" but "which of my tasks should it handle?" Most teams will end up routing, because the evidence says no single model is the best value across the kinds of work a codebase generates. The flow below is a starting point built from the data in this guide, not a rule; your own measurements on your own repository should overrule it.

If you are an individual developer on Copilot Pro or Pro+

Make MAI Code 2 your default for everyday agent work while the promotion lasts, and switch deliberately rather than by habit. Use it for the requests where you can see at a glance whether the result is right: a failing test to fix, a script to write, a component to build from a screenshot, a change across a handful of files with tests that cover them. When you are asking the model to understand code you do not understand yourself (an unfamiliar repository, a subtle refactor, tests for untested legacy code), pick GPT-6.2 Sol or Claude Opus 5.5 instead, because that is exactly where SWE Atlas shows MAI Code 2 trailing by 4 to 14 points. Keep effort at the default unless a task fails; max effort on a cheap model is still cheap, but it is slower, and the model card warns that higher effort "does not always improve results."

If you run a team on Copilot Business or Enterprise

Treat the launch as two decisions. The first is governance: MAI Code 2 is probably already enabled in your organization through default model enablement, its post-training used prompts from individual Copilot plans (not, on Microsoft's disclosure, from Business and Enterprise), and its red-team findings on circumventing safeguards argue for branch protection on CI configuration and test files before you widen agent autonomy. The second is cost: with AI credits pooled across seats, the model mix decides how far the pool stretches, and a team that defaults to MAI Code 2 for routine work and reserves frontier models for the hard tail can do many times more agent work per dollar than one that defaults to a frontier model. Plan the budget on standard prices, not promotional ones, so May 2027 is not a surprise.

If you build your own agents

You cannot call MAI Code 2 from your own code yet. Only Flash is available, and only in a limited-access preview in Microsoft Foundry through the OpenAI-compatible Responses API, and Microsoft says both models will "soon" reach OpenRouter, Vercel, Hermes, OpenCode and Kilo - Microsoft AI.

Large enterprises have a third route: MAI Licensed Weights lets customers "deploy and customize Microsoft AI models in their own Azure environments," AT&T is listed as having customized both MAI Code 2 Flash and Code 2, and broader access is "coming soon through our Frontier Company engagements," with no price published - Microsoft AI. When the models reach the open channels, remember that MAI Code 2 was reinforcement-trained inside the Copilot CLI and VS Code harnesses; its scores in your harness may differ, in either direction, and it is worth running your own evaluation before you trust Microsoft's. Until then, the comparable open choices for cheap agent work are GPT-6.2 Sol, GPT-6 Luna, Claude Haiku 5.5 (watch the 100,000-token threshold) and the open-weight models covered in our guide to open-source AI coders.

If you want outcomes rather than models

Some teams should not be making this decision at all. Every hour spent tuning effort levels, routing rules and cache behavior is an hour not spent on the product, and for a small company the arithmetic of this guide may matter less than shipping. Platforms that run the work end to end take the model choice on themselves: O-mega, for example, builds and runs a whole autonomous company (website, app, billing, content and admin) through one conversation, so the per-task model economics become the platform's problem rather than yours. The trade-off is control: you give up choosing the model for each step in exchange for not having to.

When not to use MAI Code 2 at all

Three situations argue against it regardless of price. Hard, long autonomous runs: the Terminal-Bench 4 result and Microsoft's own caveat say this is not what the model is for. Security-critical changes without review: the alignment findings mean an unattended agent with broad permissions is the wrong deployment for any model rated "less aligned than GPT-6" by its maker's red team - Microsoft AI model card. Workloads that need reproducibility over months: GitHub notes that MAI models are "continuously improving" and that performance and behavior "may evolve over time as new checkpoints are released" - GitHub Docs, so a pinned, versioned model from another provider is the safer base for anything you must audit later.

15. Outlook: What Microsoft's Own Models Mean for Coding Prices

Start from the structural fact this launch makes visible: the cost of the median coding task is collapsing, and the cost of the hardest task is not. MAI Code 2 Flash finishes Microsoft's everyday benchmark tasks for about five cents each. Claude Fable 5.2 at max effort spends $26.54 per task on Artificial Analysis's index. Those two numbers, measured on different task suites, sit more than 500 times apart, because they are priced by different forces. The median task is priced by serving cost, which falls with sparse architectures, owned chips and fierce competition. The hardest task is priced by capability, which only a few labs can supply and which costs whatever its scarcity allows.

Four things follow from that, and each is testable over the next year.

Routing becomes the product. If the cheap model handles most tasks and the frontier model handles the rest, the value moves to whoever decides which is which. Microsoft shipped Decision 1.1, a routing model, at the same event - Microsoft AI, and GitHub's auto selection already places MAI Code 2 Flash in its pool. The competition to watch is not only MAI against Sol or Opus, but whose router sends your task to whose model, and whose margin that decision serves. A router owned by a company that also sells one of the models has an incentive that buyers should audit. In Copilot Fusion that is possible: hovering over the effort level under a response lists the models used - GitHub Docs.

The promotion is a test of switching costs. Six months at half price is long enough for a team to make MAI Code 2 its default and build habits around it. On May 17, 2027, Microsoft learns how much of that usage stays at double the price. If GPT-6.2 Sol's token efficiency holds and MAI Code 2's does not improve, the post-promotion comparison on everyday work will be close, and the decision will come down to defaults and inertia rather than value. Buyers who measure cost per finished task will notice; buyers who look only at the picker will not.

Owning distribution changes who can build a frontier-adjacent model. MAI Code 2 is built from three inputs few companies have together: a coding assistant whose users supply task data, a production harness to train in, and access to frontier models for synthetic data. That combination lets a fast follower reach near-frontier everyday performance without frontier research costs. It also explains a tension worth watching: in June, Microsoft AI wrote that "we train our reasoning models from scratch. We don't distill from other labs" - Microsoft AI, while the MAI Code 2 data card names GPT-5.6 Sol and GPT-6 Astra as generators of post-training synthetic data. Those statements can both be accurate under a narrow definition of distillation, but the second one is the more useful fact for anyone predicting how quickly distribution owners can follow the frontier.

The labs will compete on tokens per task, not token prices. OpenAI kept GPT-6.2 Sol's price and cut its token use. Anthropic priced Fable 5.2 20% below Fable 5.1, at $8 and $40 against $10 and $50, with cache reads at 0.025 times the input price - Claude Docs. Neither matched a $0.50 input price, and neither needs to for the hard tail of work, where a few points of success rate are worth far more than the token bill. Expect the labs to concede the cheapest tier of routine work to distributors' house models and fight hardest where failures are expensive, which is also where their margins are.

The practical conclusion for a team is unglamorous. Use MAI Code 2 and Flash for what they are demonstrably good at, while they are cheap. Keep a frontier model for comprehension-heavy and long-running work. Measure cost per finished task on your own repository rather than trusting anyone's ratio, including this guide's. And put a reminder in the calendar for May 17, 2027.

What this article rests on

Every model figure above is read from its record, re-read from OpenRouter's model feed every 6 hours, so the figures on this page are current even where the prose around them is older. Prices are OpenRouter's listed price per million tokens: for a lab's closed models that is the lab's own list price, and for an open-weight model it is the price of the host OpenRouter routes to by default, which can differ from the lab's own API and from other hosts.

  • GPT-6 Luna (OpenAI): $0.10 in and $0.50 out per million tokens, cached input $0.01, a 1.05M token window, listed 22 September 2026.
  • Claude Haiku 5.5 (Anthropic): $0.10 in and $0.50 out per million tokens, cached input $0.01, a 1M token window, listed 7 October 2026.
  • GPT-6.2 Sol (OpenAI): $2 in and $10 out per million tokens, cached input $0.10, a 1.05M token window, listed 17 November 2026.
  • Claude Sonnet 5.5 (Anthropic): $2 in and $10 out per million tokens, cached input $0.10, a 1M token window, listed 28 September 2026.
  • Claude Opus 5.5 (Anthropic): $4 in and $20 out per million tokens, cached input $0.20, a 1M token window, listed 22 September 2026.
  • Claude Fable 5.2 (Anthropic): $8 in and $40 out per million tokens, cached input $0.20, a 1M token window, listed 9 November 2026.
  • GPT-6.2 Astra (OpenAI): $8 in and $40 out per million tokens, cached input $0.40, a 1.05M token window, listed 17 November 2026.

In this topic: AI models

Which AI model should your agents run on? Every guide on it