📑 Table of contents

Microsoft Aion 1.0 Instruct: an MIT open-weight model that becomes Edge's native engine

LLM & Modèles 🟢 Beginner ⏱️ 15 min read 📅 2026-11-20

Microsoft Aion 1.0 Instruct: an MIT open weight model that becomes Edge's native engine

🔎 AI inference enters the browser — and nobody is talking about it enough

While everyone is watching the benchmarks of the cloud giants, Microsoft has just taken a much more discreet, but potentially more structuring step: Edge's Prompt API now runs on Aion 1.0 Instruct, a 2.3 billion parameter model under the MIT license, whose weights are publicly available on Hugging Face. It replaces Phi-4-mini, the 4B model that had powered the browser until now.

Why does it matter? Because the browser is the only universal runtime. If on-device inference becomes a standard building block there — the way WebGL was for 3D — then every web developer inherits local AI capability for free, with no server, no API bill, and no data leaving the machine.

And the signal is twofold: on one hand, a lighter model that broadens hardware compatibility (Microsoft explicitly mentions machines "with less powerful GPUs or no GPU"); on the other, a hybrid AI strategy where local handles everyday tasks and the cloud takes on the heavy lifting. This is exactly the trajectory the open weight ecosystem was already following — we saw it with GLM-5.2 and its 753B MoE under the MIT license. Aion pushes that logic all the way into the browser.


The essentials

  • Aion 1.0 Instruct (2.3B parameters) replaces Phi-4-mini (4B) as the default model for Microsoft Edge's Prompt API, with significantly lighter GPU requirements — that's Microsoft's official argument for the swap.
  • MIT license, open weights: the model is downloadable from Hugging Face, making it auditable, deployable locally, and integrable into any product — including commercial ones.
  • Edge's Prompt API is in origin trial, and an experimental Decisions API is appearing alongside it; the exact status of these APIs should be checked in the official documentation, which is evolving quickly.
  • Self-reported benchmarks (MMLU 55.15 / IFEval 83.90 per the brief): no independent reproduction is available at this stage. Treat these figures as vendor numbers, nothing more.
  • The strategic angle: hybrid local + cloud AI is becoming an architecture pattern, not a compromise. The browser is its natural entry point.

Tool Primary Use Price (June 2026) Ideal For
Microsoft Edge Testing the native Prompt API with Aion Free (includes trial quotas) Web developers
Ollama Running Aion and other SLMs locally Free Local deployment, prototyping
LM Studio Graphical interface for local LLMs Free Non-CLI users
Hugging Face Downloading Aion weights, reading the model card Free Audits, fine-tuning
Hostinger Hosting the cloud part of your hybrid app From a few €/month (price (June 2026), check on hostinger.com) VPS for AI backend
Google AI Studio Comparing cloud vs local latency Free (trial quota) Hybrid benchmarks

What exactly is Aion 1.0 Instruct?

It is a 2.3-billion-parameter language model designed "from the ground up" for on-device workloads, according to Microsoft. It covers everyday text intelligence: summarization, rewriting, intent classification. A second model, Aion 1.0 Plan, is positioned in a planning role — in other words, the component that reasons about the steps before executing them.

Three characteristics distinguish it from the Phi lineage:

  1. The MIT license. No commercial use restrictions, no user-count clauses. You can embed Aion in a paid product without open-sourcing your code. That is rare from a vendor of this size, and it contrasts with certain "open weight" licenses that come with strings attached.

  2. The size. 2.3B versus 4B for Phi-4-mini. Where Phi-4-mini required sometimes demanding hardware, Aion is described as "supported on devices with less capable GPUs or no GPU" — literally, in the GitHub repository of the Edge documentation.

  3. The browser integration. Aion is not just one more model in a zoo: it is the engine behind Edge's Prompt API. This is an architectural choice, not a mere add-on.

The difference between open weight models and service models

A service model, you consume. An open weight model, you own. With Aion, Microsoft is making a bet: give away the weights to lock in the layer above (the browser, the APIs). This is the pattern we observe everywhere across the 2026 LLM landscape — and the comparison of the best open weight LLMs right now shows it every month: MIT/MIT-like models now dominate on-device use cases.

Why replace a 4B with a 2.3B? The answer fits in one sentence

Because a smaller, faster, more efficient model expands the base of compatible machines — and the base of compatible machines is the addressable market. Microsoft says it outright in its June 2026 announcement post: Phi-4-mini's hardware requirements "have limited its availability across devices".

The logic is airtight, and it deserves to be broken down:

  • A 4B in native precision generally requires 3 to 5 GB of memory for inference, before any aggressive quantization. On an 8 GB laptop with the OS, the browser, and a few tabs open, it doesn't fit.
  • A quantized 2.3B drops below the 2 GB mark in most formats. Where a 4B ruled out entry-level machines and modest Chromebooks, a 2.3B fits.
  • Inference speed on the same silicon mechanically increases: fewer parameters, less memory bandwidth consumed per token.

The trade-off, of course, is raw capability. A 2.3B will never do what a 70B does, let alone what the leaderboard's flagships do — a Gemini 3.1 Pro at 92 points or a GPT-5.5 at 91. But that's not the match. The match is "AI available on 100% of machines versus 70%".


Prompt API and Decisions API: What You Can Actually Code

Edge's Prompt API exposes Aion via a LanguageModel-type interface, available in origin trial in recent Edge builds. Concretely, a web developer can send a prompt to the local model and receive a response, with no backend, no API key, and no marginal cost per request.

Aion's system prompt is designed to be effective on three types of tasks, according to the official documentation:

  1. Summarization — compressing a long text into a few key points.
  2. Rewriting — rephrasing, correcting tone, adapting the register.
  3. Intent classification — routing a user request to the right action. This is the most strategic use case: it's exactly what's needed to drive AI agents locally.

The Decisions API: local routing before cloud

The most interesting part, but also the least documented, is the experimental Decisions API. The idea: let the local model judge whether a task can be handled on-device or whether it warrants a round-trip to the cloud. An inference pre-router, so to speak.

However, be careful: the exact status of this API — origin trial, experimental flag, or simply a proposal — must be verified in the Prompt API documentation before any production commitment. Microsoft's web platform APIs move fast, and a blog post is no substitute for reference documentation.

What this changes for web developers

For the first time, a mainstream browser ships with a text inference capability built in. The Writing Assistance APIs (summarization, translation) already use it. If this pattern takes hold, on-device AI in the web will do what Service Workers did for offline mode: invisible to the user, structuring for developers.


Self-reported benchmarks: caution is warranted

The MMLU 55.15 and IFEval 83.90 figures are circulating alongside the model, but no independent reproduction is available at this stage. They should therefore be read as vendor figures, not as benchmark ground truth.

Two levels of interpretation:

  • MMLU at 55 on a 2.3B model: that's consistent for this model size. For comparison, frontier models comfortably exceed 85 on this metric. Aion is not a reasoning model, and it's not meant to be one.
  • IFEval at 83.90: instruction following is the name of the game for a browser model, which must obey precisely what the code asks of it. A high score here is more meaningful than an average MMLU — and it's also the signal that community benchmarks are starting to better evaluate small models.

The habit to adopt before citing these figures

Before publishing or making any technical decision, check the model card on Hugging Face (microsoft/Aion-1.0-Instruct): it's the primary source for the evaluation conditions, the contexts tested, and the declared limitations. Until a third party has reproduced the results on the same configs, treat these numbers as working hypotheses.

It's a rule I apply to all recent models: the trajectory we saw with the debate around GLM-5.2 and its self-reported benchmarks confirms it — open weights give you the means to verify, but it requires doing the work.


Hybrid AI: the pattern that crushes the "local OR cloud" debate

The real lesson of Aion isn't the model: it's the architecture. Microsoft isn't positioning Aion against the cloud, but alongside it. Local handles what needs to be fast, private, or free at scale; the cloud handles what needs to be powerful.

This pattern has a name in the industry: hybrid AI. And it breaks down into three tiers:

Tier Typical model Latency Marginal cost Use cases
On-device (browser) Aion 1.0 Instruct, SLM 2-8B < 100 ms None Autocomplete, classification, short summarization
Powerful local (workstation/server) Quantized 30-70B models, see our local LLM guide 200 ms - 2 s Electricity Private RAG, sensitive content generation
Frontier cloud Gemini 3.1 Pro, GPT-5.5, Claude Opus 4.7 1-10 s Billed per token Heavy reasoning, complex agents

Why now is the right time

Three signals converge in 2026:

  1. Open-weight SLMs have become competent at targeted tasks. Cohere North Small Translate beats DeepL and Google Translate on WMT26 with a modest-sized open-weight MoE — translation is just one example among many of this specialization.
  2. Frontier models have never been this good at agentic tasks — GPT-5.5 scores 98.2 on the agentic axis in our monthly comparison. But their marginal cost remains prohibitive for mass-scale tasks.
  3. The browser has become a credible inference runtime. Edge with Aion, and behind it, WebGPU maturing in Chrome and Firefox.

The privacy argument everyone underestimates

A banking, healthcare, or HR user doesn't want their text sent to a third-party server just to be summarized. With Aion in the browser, the data never leaves the machine. For regulated sectors, that's a buying argument, not a gimmick.

And for developers who want to take the logic all the way — local AI on their own server rather than in the browser — our guide to installing a local LLM with Ollama or LM Studio remains the fastest entry point. On a Hostinger VPS costing a few euros a month, you can run a quantized 7B model 24/7 for the price of a coffee.


How to try Aion right now: three paths

Three routes, depending on your profile: casual user, web developer, or on-device engineer.

Path 1: Edge user

Download Edge (preferably a Canary or Dev build if you want the most recent APIs), enable the Prompt API in edge://flags if it isn't active by default yet, and try out the Writing Assistance APIs that rely on Aion. Check the exact status of the origin trial in the docs: the trial windows have a limited duration and a compatibility flag to comply with.

Path 2: web developer

The Prompt API is used on the JavaScript side, with no backend:

const session = await LanguageModel.create();
const result = await session.prompt("Summarize this paragraph in 3 points: ...");

That's the expected pattern — but check the exact signature in the Prompt API docs, it has changed between preview versions. For more advanced developer-side tool pipelines, our article on Code Mode in Claude Code shows how to chain tool calls in JS — a logic that will transpose to agents in the browser.

Path 3: on-device engineer

Download the weights from Hugging Face, convert them to GGUF format if needed, and run it with Ollama:

ollama run microsoft/aion-1.0-instruct

This is the most flexible option: you control quantization, context, and the target hardware. To go further in orchestrating local agents, our guide on open source AI agents with Ollama details the frameworks worth considering.

What Aion means for the open weight ecosystem

An MIT model from Microsoft, as the native engine of a browser with hundreds of millions of users, is a market signal. Competitors can't ignore this ground.

Three likely consequences over the next 12-18 months:

  1. The standardization of the Prompt API. If Chrome, Firefox, and Safari follow suit with their own implementations — or if the W3C picks up the work — we'll soon have a standard web inference API, just as we have an audio or geolocation API. The debate will no longer be "should we do it" but "which model to ship with."

  2. The normalization of MIT models. When the largest browser vendor publishes under MIT, the argument for commercial licensing becomes weak. We're already seeing this in the trajectory of Chinese and European open weight models.

  3. The rise of hybrid AI as the default architecture. The local browser for routing and simple tasks, the cloud for reasoning. The new generation of AI agents — the ones we describe in our LLM selection for agents — will be designed for this hybrid mode from the ground up.


❌ Common Mistakes

Mistake 1: confusing "Edge's native engine" with "available in any browser"

The Prompt API with Aion is a Microsoft Edge-specific feature, not a web standard. Chrome has its own approach (Gemini Nano via Chrome's AI API), while Firefox and Safari are on different trajectories. If you're building an extension or a web app, detect the API's presence and provide a cloud fallback — otherwise your users outside Edge won't see anything.

Mistake 2: taking vendor benchmarks at face value

MMLU 55.15 and IFEval 83.90 are self-reported figures, not independently reproduced to date. This is the classic pattern: the number published at launch serves the marketing, and the real value gets confirmed (or not) six months later in community benchmarks. Test on your own use cases before making any commitment.

Mistake 3: thinking a 2.3B can replace a cloud model

A 2.3B SLM is a specialized tool, not a Swiss Army knife. It summarizes, rewrites, classifies. It doesn't reason through engineering problems, doesn't perform complex document research, and doesn't drive multi-step agents on long-running tasks. As a complement, yes. As a replacement, no — which is precisely why the Decisions API for routing makes sense.

Mistake 4: forgetting about memory consumption in production

Even a 2.3B consumes RAM — typically 1.5 to 2 GB when quantized. On a web page already running alongside ten tabs, this can trigger GC and latency. Plan for session release, smart caching of results, and detection of available memory before launching inference.


❓ Frequently Asked Questions

Is Aion 1.0 Instruct free?

Yes. The model is downloadable on Hugging Face under the MIT license, which allows commercial use without royalties. Running it in Edge is free within the origin trial quotas, but check the current quota policy in the Microsoft documentation before any deployment.

Can you run Aion without a GPU?

Yes, that's the central argument for replacing Phi-4-mini. Microsoft states that the model is supported "on machines with less powerful GPUs or no GPU", which significantly widens the compatible hardware base compared to the previous 4B model.

What's the difference with Phi-4-mini?

Aion is smaller (2.3B vs 4B), faster, and has lighter hardware requirements. It's designed specifically for on-device use, whereas Phi-4-mini came from a more general lineage. Phi-4-mini remains relevant for heavier use cases, outside the browser.

Is the model really open source?

It is open weight under the MIT license: the weights are public and use, including commercial use, is permitted. It's not quite "open source" in the strict sense (the training code and data are not published), but the MIT license is one of the most permissive on the market.

Can you use Aion in a commercial product?

Yes, the MIT license allows it without restriction. You can embed it in a SaaS, a mobile product, or a desktop app without open-sourcing your code. This is one of the major advantages compared to the more restrictive licenses sometimes seen on open weight models.

How can you verify the benchmarks?

The primary source is the Hugging Face model card for microsoft/Aion-1.0-Instruct. But the best approach is still to test on your own data: a 2.3B SLM can perform very differently depending on the domain, the language, and the prompt format.

Does Edge support Aion on macOS and Linux?

The Microsoft documentation indicates broader architecture support via Aion compared to Phi-4-mini, but actual availability depends on the Edge version and the platform. Check the Prompt API documentation and the release notes for your specific build before committing.


✅ Conclusion

Microsoft has just flipped on-device AI inference from the status of a technical curiosity to that of a standard building block of the browser — and it's doing so with a 2.3B MIT-licensed model whose weights are public. The benchmarks still need to be independently confirmed, the Decisions API is still experimental, but the strategic direction is crystal clear: hybrid local + cloud AI is the new default architecture of the web. If you want to follow how the model landscape evolves — including new open-weight entrants — our monthly comparison of the best LLMs is updated every month.