Excel Contains the Loop

How the spreadsheet that defined the Windows era is now defining native AI

n 1987, if you wanted to see what Windows was actually for, you opened Excel. Not a demo. Not a shell. A real application built so deeply into the platform that the two were hard to separate. Nearly forty years later, history is rhyming. If you want to see what native AI actually looks like in a production application used by hundreds of millions of people, open Excel again.

Here is the claim, stated plainly: Excel doesn’t host AI. Excel is the harness. Microsoft now owns the full stack inside a single product: the specialized model, the agent harness it runs in, and the calculation engine underneath it all. No other mainstream application can say that today.

The Short Version

Agent Mode in Excel runs a genuine agentic loop. The model reasons about a task, acts directly on the grid, inspects the results, reflects, and iterates until the work validates. On July 23, Microsoft AI announced that a specialized MAI model, hill-climbed from the MAI-Code-1-Flash checkpoint inside an Excel reinforcement learning environment, is now serving live traffic. Microsoft reports it performs on par with GPT-5.6 on the most common Excel tasks at a fraction of the serving cost, running on H100 and even A100 class GPUs rather than requiring the latest accelerators.

That combination, a product-specific model trained inside a product-specific harness against product-specific evaluations, is what native AI actually means. Everything else is a chatbot in a sidebar.

The 1987 Mirror

When Excel shipped for Windows, “native” was a technical claim with teeth. Excel drew through GDI, defined file formats the platform learned to speak, pioneered OLE so objects could live inside other documents, and carried its own runtime in the form of the calculation engine. The dependency graph of a workbook was, and still is, a live program. Every recalculation is code execution.

That depth is why Excel didn’t just run on Windows. It sold Windows. The application proved the platform.

The AI era has its own version of thin versus deep. Most “AI features” shipping today are overlays: a frontier model behind an API, a prompt template, and a text box grafted onto an existing product. Useful, sometimes. Native, no. The model knows nothing structural about the application, the application knows nothing about the model, and the integration surface is a string of text passing between them.

What Native AI Actually Requires

Three layers, all owned, all trained against each other.

First, the product environment itself. Excel brings a forty-year-old calculation engine, a live dependency graph, and file formats the world runs on. This is the ground truth the agent operates against.

Second, the agent harness. This is the machinery that lets a model perceive the workbook, act on it, and check its own work. The harness is where most AI integrations quietly fail, because building one well requires deep product internals that an API partner never sees.

Third, a model specialized against that harness. Not a general model prompted cleverly, but weights actually updated by reinforcement learning inside the product’s own environment, graded by the product’s own evaluations.

Microsoft now has all three in one product. That is the story.

Anatomy of the Harness

The Excel team’s engineering write-up on Agent Mode is unusually candid, and the architecture rewards a close read.

The core is a reasoning and reflection loop. The agent plans, executes a step, observes the actual state of the workbook, and revises. It does not generate a spreadsheet in one shot and hope. It works the way a careful analyst works, incrementally and with verification.

Feeding that loop is what the team calls a hybrid document context approach. Workbooks are far too large to stuff into a context window, so the harness pushes a compact structural blueprint of the workbook to the model, then lets the model selectively pull the specific ranges, formulas, and objects it needs. Push the map, pull the terrain. This is the pattern every team building agents over large structured documents will end up reinventing, so study the original.

Execution happens directly on the grid through Excel’s JavaScript and Office.js APIs. The agent writes real formulas into real cells. It does not emit a static snapshot of values. That distinction matters enormously, because it means the output preserves the live dependency graph. Change an input and the model’s work recalculates, exactly as a human-built workbook would. The calculation engine, the same runtime that made Excel native to Windows, is now the substrate that keeps agent output alive.

Validation is built into generation. The harness checks the agent’s work against the actual state of the workbook, catches errors, and feeds them back into the loop. And the whole harness is model-agnostic by design, with distilled Excel domain knowledge living in the harness rather than hardcoded to any single model. That decision looked like good engineering hygiene in 2025. In 2026 it turned out to be the setup for something bigger.

The Specialized Model and the Flywheel

On July 23, Microsoft AI’s Superintelligence team published results that close the loop, literally. They took MAI-Code-1-Flash, their lightweight agentic coding model already post-trained inside the GitHub Copilot harness, and used it as the starting checkpoint for further reinforcement learning inside an Excel environment. The model learned Excel’s tools and knowledge workflows the way it had previously learned software engineering: by acting, being graded, and updating.

The reported outcome from live production traffic: quality on par with GPT-5.6 for the most common tasks, from a model small enough to serve on previous-generation GPUs. Microsoft frames the deployment economics as a significant cost reduction, and the strategic framing is explicit in their own words. Access to the entire product stack, the model, the harness, the agents, and product-specific evaluations, is what lets them hill-climb small models into territory previously reserved for large expensive ones.

The product is not consuming AI. The product is manufacturing it.

Read that sentence again as a product strategist. The harness that the Excel team built to be model-agnostic became the training environment. The evaluations built to test the product became the reward signal.

The Supporting Architecture

Around the core loop, the pieces keep compounding. Agent Mode routes across multiple models, with frontier options from OpenAI and Anthropic alongside the specialized MAI model, selectable or automatic. Python in Excel gives the agent a second execution surface for analysis the formula language handles poorly. Finance skills and data connectors ground the agent in domain workflows. The Notebook-to-Excel handoff lets exploratory agent work graduate into governed workbooks. And local workbook support brought the loop from web to desktop between December and January.

Each addition makes the harness richer. A richer harness makes a better training environment. A better training environment makes a stronger specialized model. Microsoft has already said it is extending the same hill-climbing approach to Copilot Chat, Outlook, and PowerPoint. Excel just got there first, again.

The Template for AI-Native Software

If you build software, this architecture is the clearest living answer to a question every product team is currently facing: what does it mean to make our product AI-native rather than AI-adjacent?

The lesson is not “train your own model.” Most companies shouldn’t and can’t. The lesson is that the harness is the product now. The durable engineering investment is the layer that gives an agent structured perception of your domain, safe tools to act with, and evaluations that define what good work looks like. Build that layer well and it pays twice: it makes any frontier model dramatically better in your product today, and it becomes a training environment the moment specialized models are worth the investment.

The competitive moat follows directly. A bolted-on chatbot can be replicated by any competitor with an API key in a quarter. A harness built on decades of product internals, wired to a live runtime like the calculation engine, generating proprietary evaluation signal from real usage, cannot. Full-stack ownership compounds. Overlays don’t.

The Loop Closes

There is a satisfying symmetry here. Excel became the defining Windows application because it was inseparable from the platform: its rendering, its object model, its runtime. Excel is becoming the defining native AI application for the same reason. The calculation engine that made spreadsheets programmable in 1987 is now the environment where an agent’s work stays alive, and the harness wrapped around it is now the environment where the model itself gets smarter.

Excel doesn’t call out to the loop. Excel contains it.

---

Sources & Further Reading

1. Hill-Climbing MAI Models for GitHub Copilot and ExcelMicrosoft AI · July 23, 2026 · Primary source for the specialized Excel MAI model and the model + harness + evaluations flywheel

2. Building Agent Mode in ExcelMicrosoft Tech Community, Excel Blog · September 29, 2025 · The detailed technical description of the reasoning loop, hybrid context, and on-grid execution

3. Vibe Working: Introducing Agent Mode and Office Agent in Microsoft 365 CopilotMicrosoft 365 Blog · September 29, 2025 · Launch announcement and user-facing framing

4. Building a Hill-Climbing Machine: Launching Seven New MAI ModelsMicrosoft AI · June 2, 2026 · The broader hill-climbing philosophy and the MAI-Code-1-Flash lineage