# MAI-Code-1.1-Flash MAI-Code-1.1-Flash is the coding model built by Microsoft AI, the [[Microsoft]] division that trains the company's own "MAI" models (it also ships MAI-Thinking-1, MAI-Voice-2.1, MAI-Transcribe-2 and MAI-Image-2.6). It's made for [[GitHub Copilot]]: Microsoft trained it inside the same agent loop Copilot uses in production, and you pick it from the model picker in VS Code, the [[GitHub Copilot CLI]] and the [[GitHub Copilot App]]. Microsoft doesn't offer it outside Copilot. Version 1.1 came out on 11 August 2026 (Frandroid's date) and replaced MAI-Code-1-Flash, which launched at Microsoft Build in June. On 7 October 2026, Microsoft announced a quantized version that runs on the laptop itself, with no per-token bill for local calls. That's the part that made the news, because of the memory it asks for: 53 GB for the weights, 75.5 GB at peak, and Microsoft recommends more than 120 GB of RAM for the best performance. ## Timeline - **2 June 2026**: MAI-Code-1-Flash launches at Microsoft Build, for GitHub Copilot individual users in VS Code. Microsoft says it trained the model "from the ground up" on its own data, without distilling third-party models, and compares it to Claude Haiku 4.5 (51.2% vs 35.2% on SWE-Bench Pro, in Copilot's own setup) - **11 August 2026**: MAI-Code-1.1-Flash. Microsoft claims a quarter of the price of 1.0, image inputs, 22% better on Terminal-Bench 2.1 in the Copilot CLI, 15% better on .NET tasks, 4% more generated code surviving to the commit, and output that streams 25% faster with 25% fewer tokens per task - **7 October 2026**: the local version is announced on Microsoft's Command Line blog, alongside the Surface Laptop Ultra (preorders that day, deliveries from 16 October according to Frandroid) - **End of October 2026**: experimental access to local models in the Copilot CLI, the Copilot app and VS Code ## Specs - Architecture: sparse [[AI Mixture of Experts (MoE)|mixture of experts]], 137B parameters in total, 6.8B active per token (Command Line post). The model card, which still describes 1.0, says 5B active; I found no card for 1.1 - [[Context Window|Context window]]: 256K tokens, kept in the local version - Inputs: text and images since 1.1 (the 1.0 card says text only). Output: text - Training (1.0 card): March to May 2026, data cutoff December 2025, started from MAI-Thinking-1's mid-training checkpoint, then about 2 million synthetic agentic tasks and reinforcement learning over 150,000+ environments. For 1.1, Microsoft mentions "hundreds of thousands" of RL environments in Copilot - Cloud price in Copilot: $0.20 per million input tokens and $1.20 per million output tokens, against $0.75 / $4.50 for 1.0 (Frandroid, citing Windows Report) - License: no open-weight license. The 1.0 model card says use is governed by the terms of the product it's deployed in (VS Code, GitHub Copilot). The `microsoft/MAI-Code` GitHub repository is MIT-licensed, but it only holds a README, used for release notes and feedback issues; there are no weights in it ## The local version Microsoft compressed the cloud model (stored in BF16, 16 bits per weight) with mixed-precision [[AI Quantization|quantization]] down to about 3.3 bits per weight on average. The result weighs 53 GB, 80% smaller than the cloud variant. To make it faster, it adds [[AI Speculative Decoding|speculative decoding]] (a small drafter proposes blocks of tokens that the big model checks in one pass), with a "DFlash2 sliding-window" drafter running on a Windows ARM64 build of [[llama.cpp]] with CUDA. The 75.5 GB figure from the headlines is the peak at 256K tokens of context, not the size of the model. The difference is mostly the [[AI KV Cache|KV cache]], which grows as the agent reads files and receives tool output. Microsoft's post says it clearly: on unified memory, the weights only get part of the pool, because the OS, your apps and the inference runtime need memory too. Its own conclusion is that "the useful question isn't just whether a model fits, but how it behaves over a complete coding task". Measured performance (Microsoft, 5 October 2026, Surface Laptop Ultra): - Prompt processing: 923.5 tokens/s at 64K context, 769.8 tokens/s at 128K - Peak memory: 75.5 GB at 256K context The target hardware is NVIDIA RTX Spark Windows PCs, starting with the Surface Laptop Ultra (up to 128 GB of unified memory, "up to 1 petaflop" of AI compute). Frandroid lists the US prices: $2,599 with 24 GB (too small for the model), $4,299 with 64 GB (not enough for the full context) and $5,899 with 128 GB. Frandroid adds that other machines with enough memory (AMD mini PCs, Mac mini, Mac Studio) can run it too; Microsoft's post only talks about RTX Spark PCs. ## Benchmarks Microsoft's table for the local release: | Benchmark | Tasks | MAI-Code-1.1-Flash (cloud) | GPT-OSS-120B (Unsloth GGUF) | MAI-Code-1.1-Flash (local, quantized) | |---|---|---|---|---| | [[SWE-Bench]] Verified | 500 | 72.6% | 32.0% | 70.8% | | Terminal-Bench 2.1 | 89 | 62.9% | 23.6% | 66.3% | The only competitor in that table is OpenAI's open-weight GPT-OSS-120B, in a GGUF build from [[Unsloth]]. Microsoft didn't compare it to Claude or GPT models; the "Microsoft takes on Claude and GPT" angle is Frandroid's. Frandroid put the score next to the Vals AI Terminal-Bench 2.1 leaderboard, which I checked (updated 28 September 2026, Terminus 2 setup): | Model | Terminal-Bench 2.1 (Vals AI) | Price per million tokens (in / out) | |---|---|---| | [[Claude Opus 5.5]] | 87.64% | $4 / $20 | | [[GPT-6 Astra]] | 87.27% | $10 / $50 | | [[Claude Sonnet 5.5]] | 83.15% | $2 / $10 | | [[GPT-5.6]] Luna | 79.03% | $0.20 / $1.20 | | [[GPT-6 Luna]] | 73.03% | $0.10 / $0.50 | | MAI-Code-1.1-Flash (Microsoft's own run) | 62.9% (cloud), 66.3% (local) | $0.20 / $1.20 (cloud), free (local) | Different setups, so read it as an order of magnitude. Even with that caveat, the model sits well behind the frontier, and behind GPT-5.6 Luna, which costs exactly the same per token. [[Claude Haiku 5.5]] and GPT-6 Luna are cheaper still ($0.10 / $0.50). One oddity: the quantized model beats the full-precision one on Terminal-Bench (66.3% vs 62.9%). On 89 tasks, that gap is 59 solved tasks against 56. Three tasks is noise: read it as "no measurable loss" from quantization. ## How to use it in GitHub Copilot From the end of October 2026, in experimental access, in the CLI, the app and VS Code: 1. **Auto**: Copilot decides, per task, whether to run it on the local model or in the cloud. Microsoft says the router considers the task context and the cache state, so it can keep work that is already cached. This extends Project HydraFusion, GitHub's multi-model orchestrator, to the edge (see [[Model routing]]) 2. **Explicit selection**: you pick MAI-Code-1.1-Flash yourself through the Windows ML provider, or you point Copilot to any local endpoint compatible with the OpenAI API and pick one of its models. [[Ollama]] and [[LM Studio]] both expose that kind of API, so the second option isn't tied to Microsoft's model at all In both modes, the commands the agent runs can go through a sandbox: [[GitHub Copilot Sandboxing|Copilot's local sandboxing]], built on [[Microsoft eXecution Container (MXC)|MXC]]. Turn it on with `/sandbox` in the CLI or with the "Sandbox new sessions" toggle in the project settings of the app. Microsoft's example is a daily automation that builds a triage dashboard for the `copilot-sdk` repository, with the local model and the sandbox enabled. One contradiction in the announcement: Microsoft writes that "local inference does not make the session offline". Model selection, inference and tool execution are separate things. The same post then describes the dashboard example as working "off-line", so don't assume a fully disconnected setup until you've tested it. ## My take I find the router more interesting than the model. A 3-bit coding model on a laptop is a nice demo, but Auto mode sending the easy steps to local hardware and the hard ones to the cloud is the same idea as routing between cheap and expensive cloud models, with one more tier that costs nothing per token. If it works well, you stop thinking about where each request runs. The economics, though, don't favor the laptop. The 128 GB Surface Laptop Ultra costs $3,300 more than the 24 GB one. At the cloud price of the same model, $3,300 buys about 2.75 billion output tokens, or 16.5 billion input tokens. Very few developers burn through that before the laptop is obsolete. So the reasons to run it locally are the usual ones from [[Running AI Models Locally]]: code that can't leave the machine, flaky connections, independence from rate limits and outages. Cost is not one of them unless you already own the hardware. It's also not the best local coding model on paper. The Qwen team claims 77.2% on SWE-bench Verified for [[Qwen3.6-27B]], whose 4-bit quant weighs 16.8 GB and fits a single 24 GB GPU. Different setups again, so that's not a fair head-to-head, but it shows that 75 GB isn't the price of entry for local agentic coding. What Microsoft brings is the integration: the model, the router, the sandbox and the hardware come from one vendor and work together in Copilot. If you already have a machine with lots of memory (a Mac Studio, a big Linux box), the OpenAI-compatible endpoint option is the one I'd test first: put Ollama or LM Studio behind Copilot and try your own models before buying anything. ## Caveats - Every benchmark and throughput number comes from Microsoft, measured on 5 October 2026 on its own hardware. No independent results yet, as Frandroid points out - The active parameter count differs between the 1.0 model card (5B) and the 1.1 local post (6.8B), and there's no 1.1 model card to settle it - Microsoft AI says the model is "available to download and run locally", but the only documented way to run it is through Copilot's Windows ML provider. I found no public weights - The 1.0 vs 1.1 prices come from Frandroid, which cites Windows Report; I couldn't load the Windows Report article to check them - Frandroid's Terminal-Bench comparison puts scores from different setups side by side (Microsoft's own run vs Vals AI's Terminus 2 runs) ## References - Frandroid, "Microsoft défie Claude et GPT en local, mais réclame 75 Go de RAM avec son nouveau modèle MAI Code 1.1 Flash" (2026-10-07, updated 2026-10-08): https://www.frandroid.com/marques/microsoft/3277299_microsoft-defie-claude-et-gpt-en-local-mais-reclame-75-go-de-ram-avec-son-nouveau-modele-mai-code-1-1-flash - Microsoft Command Line, "Bringing local models and sandboxed tools to Windows and GitHub Copilot" (2026-10-07): https://commandline.microsoft.com/local-models-sandboxed-tools-github-windows/ - Microsoft AI, "MAI-Code-1.1-Flash: Better, faster, at a quarter of the cost" (updated 2026-10-07): https://microsoft.ai/news/mai-code-1-1-flash-br-better-faster-at-a-quarter-of-the-cost/ - Microsoft AI, MAI-Code-1.1-Flash model page: https://microsoft.ai/models/mai-code-1-flash/ - Microsoft AI, "Introducing MAI-Code-1-Flash" (2026-06-02): https://microsoft.ai/news/introducingmai-code-1-flash/ - MAI-Code-1-Flash model card (PDF): https://microsoft.ai/pdf/MAI-Code-1-Flash-Model-Card.PDF - MAI-Code repository (release notes and feedback): https://github.com/microsoft/MAI-Code - Vals AI, Terminal-Bench 2.1 leaderboard: https://www.vals.ai/benchmarks/terminal-bench-2-1 - Windows Report, pricing article cited by Frandroid: https://windowsreport.com/microsoft-slashes-ai-coding-costs-with-mai-code-1-1-flash/ - Unsloth's GPT-OSS-120B GGUF (Microsoft's comparison model): https://huggingface.co/unsloth/gpt-oss-120b-GGUF ## Related - [[Microsoft]] - [[GitHub Copilot]] - [[GitHub Copilot CLI]] - [[GitHub Copilot App]] - [[GitHub Copilot Sandboxing]] - [[Microsoft eXecution Container (MXC)]] - [[Running AI Models Locally]] - [[On-Device Machine Learning]] - [[AI Quantization]] - [[AI Speculative Decoding]] - [[AI Mixture of Experts (MoE)]] - [[AI KV Cache]] - [[Context Window]] - [[llama.cpp]] - [[Unsloth]] - [[Ollama]] - [[LM Studio]] - [[SWE-Bench]] - [[Model routing]] - [[AI Model Selection]] - [[Qwen3.6-27B]] - [[Claude Haiku 5.5]] - [[Claude Sonnet 5.5]] - [[Claude Opus 5.5]] - [[GPT-6 Luna]] - [[GPT-6 Astra]] - [[GPT-5.6]] - [[Phi LLMs]] - [[Large Language Models (LLMs)]] - [[AI Models (MoC)]]