Short answer: Microsoft has split the MAI Code 2 family into a “complex task tier” and a “high-frequency simple task tier.” On November 17, 2026, Microsoft released MAI Code 2 and MAI Code 2 Flash. MAI Code 2 is aimed at multi-file edits, deep debugging, and repository-level reasoning. MAI Code 2 Flash is aimed at code explanation, targeted edits, routine fixes, and high-frequency iteration. For most developers and small teams, our recommendation is to start with Flash by default for everyday small tasks, then switch to Code 2 when you hit cross-file dependencies or bugs that are hard to pin down.
What will you learn from this article?
- The official positioning of the two model tiers and the kinds of coding tasks each is meant for.
- The input/output modalities and context specs disclosed in the model cards, and how to interpret those numbers.
- Where you can use them today, which channels are only “coming soon,” and when the Copilot promotional pricing ends.
- A practical way to decide when to start with Flash and when to upgrade to Code 2 based on signals.
Index: Start with the To Know concept table and the impact at a glance to quickly find the parts relevant to you. Part 1, “Objective Facts,” is organized in order: release information, positioning of the two tiers, model card specs, available access points, and the nature of the evaluation plus promotional rates. It only covers information with sources. Part 2, “Analysis and Opinion,” is the editorial view. It discusses what the tiering means, selection advice, the practical limits of long context, and what to check before API integration.

MAI Code 2 and Flash: Concepts to Know First
| Concept | Brief explanation |
|---|---|
| Repository-level reasoning | The model needs to understand the structure of the entire code repository and cross-file dependencies, not just the current file or snippet |
| Targeted edits | Making small changes at a known location, such as modifying a function or fixing a bug |
| Context window | The maximum total tokens the model can process in a single pass, including input and output |
| Model Card | A model documentation published by the vendor, recording capability scope, specifications, benchmarks, and limitations |
| Microsoft Foundry | Microsoft’s enterprise AI model and application building platform, formerly the Azure AI Foundry system |
| limited-access preview | A restricted-access preview that requires an application or meeting conditions to use; it isn’t broadly open |
| Vendor benchmarks | Test results published by the model publisher itself, which aren’t the same as independent third-party or user testing |
MAI Code 2 and Flash Release Impact at a Glance
| Audience | Main impact |
|---|---|
| GitHub Copilot users | Both models are already available in Copilot, but under different plans; check your plan, organization policies, and current quota |
| Individual developers, small teams | An added option to pick models by task difficulty—routine small changes don’t all need to go to a heavy model |
| Azure / Foundry enterprise users | Flash is in limited-access preview and requires going through the application process; general availability timing is subject to the official announcement |
| Developers calling via third-party platforms | Channels like OpenRouter and Vercel are marked as “coming soon” in the release announcement; you can’t assume they’re callable yet |
1. What Actually Happened: The MAI Code 2 and Flash Launch
1.1 MAI Code 2 release date and sources
Microsoft released MAI Code 2 and MAI Code 2 Flash on November 17, 2026, through the official news page at microsoft.ai. Around the same time, the company explained how the models are offered on the Foundry side in a post on the Azure AI Foundry technical community blog, and published a single model card PDF shared by both models. This article also cross-checks GitHub’s official changelog and the billing documentation, with a cutoff date of November 18, 2026.
1.2 MAI Code 2 and Flash: Two Tiers of Positioning
The official division of labor between the two models is pretty clear: one handles complex tasks that require a global understanding, while the other takes on frequent, small-scope tasks.
| Dimension | MAI Code 2 | MAI Code 2 Flash |
|---|---|---|
| Official positioning | Complex programming tasks | High-frequency, routine programming tasks |
| Typical tasks | Multi-file edits, deep debugging, repository-level reasoning | Code explanation, pinpoint edits, routine fixes, high-frequency iteration |
| Task scope | Cross-file, cross-module | Single-point, local |
| GitHub Copilot | Already available | Already available |
| Foundry | Not specified in the reference materials | Limited-access preview |

1.3 Public Specs from the MAI Code 2 Model Card
The model card gives the numbers for modality and context. Note that the model card also states that the actual limits in the product may differ from these numbers.
| Item | Model card data |
|---|---|
| Input modality | Text, images |
| Output modality | Text |
| Model context | 1.05M tokens |
| Max input | 922k tokens |
| Max output | 128k tokens |
As for the total parameter count, existing sources are inconsistent across versions. This article won’t cite specific numbers; we’ll defer to official updates going forward.
1.4 Availability of MAI Code 2 and Flash
The official GitHub changelog spells it out: Code 2 is available to Copilot Pro, Pro+, Max, Business, and Enterprise; Flash also covers Free and Student tiers. Eligible annual subscriptions work too. Enterprise or organization admins can control access through model policies, so “shipped” doesn’t mean every account gets it unconditionally. On the Foundry side, the release notes only confirm Code 2 Flash as a limited-access preview — they don’t declare Code 2 fully open on Foundry.
The release also mentions channels like OpenRouter, Vercel, Hermes, OpenCode, and Kilo, but their status is “soon.” In other words, as of this writing, you can’t treat those channels as broadly available yet.

1.5 The Nature of MAI Code 2 Benchmark Data
This article contains no independent hands-on testing. Microsoft’s comparison mixes internal evaluations with external data: DeepSWE 1.1, TerminalBench 2.1, and SWE Atlas were run on Microsoft’s MSBench via Copilot CLI without sub-agents; FrontierCode 1.1 scores and costs come from Artificial Analysis. All relevant models were set to max reasoning effort, and MAI costs use the 50% promotional price. Results under these specific tasks, configurations, and pricing conditions shouldn’t be taken as general conclusions for every codebase. Microsoft also explicitly states that these two models haven’t been tuned for basic scientific research or very long agentic workflows.
1.6 Copilot promotional pricing: you need to look at both the rate and the effective date
The current promotional prices listed in GitHub’s billing documentation are below, in USD per million tokens. These follow Copilot’s billing basis and can’t be taken directly as quotes for Foundry or third-party APIs.
| Model | Input | Cached input | Output | Input / cached input / output from May 17, 2027 |
|---|---|---|---|---|
| MAI Code 2 | $0.50 | $0.025 | $2.50 | $1.00 / $0.05 / $5.00 |
| MAI Code 2 Flash | $0.05 | $0.005 | $0.25 | $0.10 / $0.01 / $0.50 |
An official footnote states that the promotion runs until May 17, 2027, and that the prices in the right-hand column take effect from that date; after that, rely on the live documentation. Day-to-day metering gets converted into GitHub AI Credits, so the allowance included in your plan, the budget for extra usage, and the older billing arrangements for annual subscriptions each need to be checked separately. This isn’t unlimited free usage, and the cost ratio during the promotional period shouldn’t be written up as a permanent discount. GitHub’s official billing documentation
2. Analysis: What the MAI Code 2 and Flash two-tier setup means for developers
The following is editorial analysis, derived from the facts in Part 1, and does not represent an official Microsoft position. Anything about future trends is a prediction.
2.1 Why MAI Code 2 Comes in Two Tiers
In coding scenarios, most requests are actually pretty “small”: explaining a snippet of code, changing a parameter, fixing an obvious error. These tasks don’t demand much global understanding from the model — what matters is fast responses and being able to call it frequently. Cross-module refactors and deep bug hunting, on the other hand, are rarer but harder per request, and they require the model to grasp the overall structure of the repository.
Splitting these two kinds of needs across two models lets users “pay according to task difficulty.” GitHub officially positions Flash as the lightweight, cost-friendly everyday development model; the current billing docs also list different per-token prices for the two models (see 1.6). But a price difference doesn’t equal a task-cost difference — response speed, token consumption, and the number of rework rounds still need to be verified in your own tasks.
2.2 Editing Recommendation: Start with Flash, Upgrade to MAI Code 2 When You See Signals
For developers and small teams, we recommend making Flash the default tier and switching to Code 2 only when a clear signal appears. This is a routing strategy still to be validated — we can’t promise Flash is faster or that Code 2 will necessarily fix the problem. You should track task pass rate, manual review time, and actual cost at the same time.
The thresholds below are editorial suggestions — a starting point that’s easy to try out, not official limits or verified optimal rules:
- The change touches at least 3 files, or requires updating an interface definition and its callers together.
- Two consecutive Flash fixes fail to solve the problem, suggesting the issue may not be local.
- The bug’s root cause lies in another module, such as configuration, dependency version, or an upstream data flow.
- You need to understand the project’s overall architecture, like mapping module relationships or planning a refactor.
- You can’t clearly say where the problem is, and need the model to do a global investigation first.
Conversely, for tasks like explaining code, writing unit test samples, renaming, adding comments, or fixing compilation errors, try Flash first, then decide whether to keep it based on test results and manual review.

2.3 A 1.05M context window doesn’t mean you can use it all in a tool
The model card says the context window is 1.05M, max input is 922k, and max output is 128k. But it also notes that actual product limits may differ. Our take: in products like GitHub Copilot, the actually usable context length and per-call output cap may be affected by product policy.
So don’t expect that “cramming the whole repo in” will solve everything. The safer approach is still to have the model look at relevant directories and key files first, then expand the scope gradually. That’s exactly where Code 2’s “repo-level reasoning” pitch adds value: it needs to find key relationships across a large amount of code, not just hold more text.
2.4 Want to call MAI Code 2 through the API? Check first, then try it
Right now, the confirmed entry points for the MAI Code 2 series are GitHub Copilot and Foundry (Flash limited preview). Third-party aggregator channels aren’t fully live yet. If you’re planning an API integration, the first step isn’t writing business code — it’s confirming whether the target platform actually offers these two models, and what the model IDs are.
The code below only illustrates the integration approach. It wasn’t run for this article, and we haven’t verified that APIYI already provides these two models. A name containing “mai” only means it’s a candidate; it can’t replace checking the official model name, API capabilities, and permissions. The example first lists models, then filters for entries that may be relevant:
import openai
client = openai.OpenAI(
api_key="YOUR_API_KEY",
base_url="https://api.apiyi.com/v1" # APIYI OpenAI-compatible endpoint; model availability is subject to the live list
)
# List currently available models and filter for entries that may be related to MAI Code 2
models = client.models.list()
mai_models = [m.id for m in models.data if "mai" in m.id.lower()]
print(mai_models or "当前列表中未找到 MAI 相关模型")
If the corresponding model does show up in the list, you can write a simple tiered routing setup based on the approach in section 2.2. Model IDs should follow the platform’s list; the placeholders below stand in for them:
View example code for routing calls by task difficulty
import openai
client = openai.OpenAI(
api_key="YOUR_API_KEY",
base_url="https://api.apiyi.com/v1" # Use APIYI's unified endpoint
)
# Placeholder: replace with real IDs confirmed in the model list
FLASH_MODEL = "YOUR_FLASH_MODEL_ID"
CODE2_MODEL = "YOUR_CODE2_MODEL_ID"
def pick_model(files_touched: int, failed_attempts: int, cross_module: bool) -> str:
"""Select a model using the signals from section 2.2: Flash by default; upgrade to Code 2 if any condition is met"""
if files_touched >= 3 or failed_attempts >= 2 or cross_module:
return CODE2_MODEL
return FLASH_MODEL
def ask(prompt: str, files_touched=1, failed_attempts=0, cross_module=False) -> str:
model = pick_model(files_touched, failed_attempts, cross_module)
resp = client.chat.completions.create(
model=model,
messages=[
{"role": "system", "content": "你是资深工程师,先说明改动范围,再给出代码。"},
{"role": "user", "content": prompt},
],
)
return f"[{model}]\n" + resp.choices[0].message.content
print(ask("解释这个函数的作用:def add(a, b): return a + b"))
🎯 Integration advice: Third-party channels for the MAI Code 2 series are still rolling out. We recommend checking the model list or docs on APIYI apiyi.com for actual support and model IDs before deciding whether to integrate. If they aren’t available yet, you can use the same OpenAI-compatible code to set up tiered routing on a coding model the platform already supports. Later you’ll still need to check API parameters, tool-calling support, cost, and regression tests; there’s no guarantee it’ll just work by changing the model ID.
2.5 MAI Code 2: Changes Worth Watching
The following are forward-looking judgments that will need to be verified against real-world developments:
- Rollout pace of third-party channels: When channels marked “coming soon” — OpenRouter, Vercel, and others — actually open up will directly shape how accessible these models are to users outside Copilot.
- Scope of Foundry access: Whether Flash moves from limited preview to general availability, and whether Code 2 makes its way into Foundry.
- Independent hands-on results: How the community and third parties perform on real repositories will say more about the actual gap between the two tiers than vendor benchmarks do.
- Real in-product limits: The actual ceilings on context and output inside products like Copilot will determine how far “repository-level reasoning” can really go.
If you want to compare different coding models side by side within the same codebase, an aggregation platform makes life easier. APIYI apiyi.com offers an OpenAI-compatible unified interface — one key lets you switch between OpenAI, Claude, Gemini, and other models — which makes it a good place to have your comparison workflow ready before new models launch.
The arrival of two tiers ultimately comes down to a simple truth: no single model is right for every coding task, and allocating tools according to how heavy the job is turns out to be the more economical approach. As the Chu Ci · Bu Ju puts it:
“A foot may fall short; an inch may run long.”
📚 References
- Official GitHub launch announcement: plans and admin policies.
-
Official GitHub pricing and promotional footnotes: rates, promotion end dates, and billing rules.
-
Microsoft official announcement: Introducing MAI Code 2 and MAI Code 2 Flash: the launch post and positioning notes
- Link:
microsoft.ai/news/introducing-mai-code-2-and-mai-code-2-flash/ - Details: what tasks each model is built for, availability in GitHub Copilot, and the “coming soon” note for third-party channels
- Link:
-
Azure AI Foundry tech community blog: From model choice to your durable advantage
- Link:
techcommunity.microsoft.com/blog/azure-ai-foundry-blog/from-model-choice-to-your-durable-advantage-build-ai-that-keeps-improving/4573609 - Details: how the models are offered on the Foundry side, plus the limited-access preview notes for MAI Code 2 Flash
- Link:
-
MAI Code 2 and MAI Code 2 Flash model card (PDF): model specs and evaluation details
- Link:
microsoft.ai/pdf/MAI-Code-2-And-MAI-Code-2-Flash-Model-Card.pdf - Details: input and output modalities, context length, maximum input and output, and the caveat that product limits may differ
- Link:
Author: APIYI technical team
Technical inquiries: If you’d like to know more about model access and support, feel free to reach us through the APIYI homepage at apiyi.com. More integration docs are available in the docs.apiyi.com documentation center.
