Microsoft has opened downloads for Aion 1.0 Instruct, a text model with about 2.29 billion parameters. Its main repository dates to November 18 and contains an unquantized weight file of about 4.58 GB under the MIT license. A separate ONNX WebGPU package is about 1.3 GB and stores the weights at lower precision. Both give developers a way to try the model on supported devices. Microsoft separately plans to begin moving eligible Windows Insider devices to Aion in December and targets a broader retail transition by late January 2027. Microsoft model card · WebGPU edition · Windows transition notice

The useful reason to pay attention is that an application can use these weights without sending every text request to a model service. That matters for a reader app rewriting a paragraph, a research tool pulling headings out of notes, or a document viewer that needs to stay responsive without a connection. The hard part now belongs to the application. It has to make the model fit the machine, fit the reader’s task and behave consistently across devices. The weights are a practical starting point for a narrow text feature. Their size and license tell us very little about how well an application will handle the text of a particular person’s next document.

Three ways to encounter Aion#

The downloadable base edition is a model package for developers who choose the runtime. It includes the weights, tokenizer, model code and a chat template. Microsoft reports about 2.29 billion parameters and uses bfloat16 weights, a format occupying two bytes per parameter before packaging overhead. The roughly 4.58 GB file size is in line with that count. On a machine that loads the weights for inference, other memory goes to the runtime and tensors needed to process the input and generate text. The file size helps estimate a download. The minimum memory for a workflow depends on runtime, context and how the device shares its memory with other programs. Aion repository files

Microsoft’s WebGPU download is a different packaging of the same model family. The card specifies four-bit weights, with half-precision activations and a half-precision cache used as text is generated. It identifies an ONNX model graph and separate weight data totaling around 1.3 GB. That is about 28 percent of the size of the bfloat16 weight file, using decimal file sizes. This is a useful reduction if an application needs users to download a model. An application still needs a compatible GPU and runtime, and the smaller stored weights leave other memory requirements in place. The card says the package targets native and browser WebGPU through compatible builds of ONNX Runtime. ONNX WebGPU model details

Stylized diagram showing a large unquantized model stack beside a smaller four-bit model inside a browser window.

The Windows edition is a third route. Microsoft describes its planned operating-system release as a further-optimized version accompanied by a local moderation model. The company is replacing Phi Silica for supported Windows AI experiences. In its November 13 transition notice, it listed December 4 as a planned start date for Windows Insider rollout and late January as the retail target. It also says support for eligible GPUs is expanding in stages. The timing and eligible devices matter more to a Windows application author than the day the Hugging Face repository opened. A prototype made with the downloadable weights can help characterize the model family. Testing the operating system feature will require the actual version and devices to which the platform delivers it. Microsoft’s Windows transition schedule

These routes make different product decisions easier. Someone building a cross-platform experiment can take the released model and track the artifacts they used. A Windows developer can try the preview framework and plan for the platform-managed release. A browser developer can consider an ONNX package and take responsibility for delivery, acceleration and memory. Those teams may all call the underlying model Aion even though one route depends on a device’s browser and another on a particular Windows rollout. A meaningful compatibility test starts by recording which route and model file it used. It can then say whether another person on a different machine should expect a matching result.

Small enough to try, large enough to notice#

The download matters because users meet a local model before they meet its first answer. At a sustained 50 megabits per second, a 1.3 GB transfer would take about three and a half minutes, even before protocol overhead and initialization. That is a hypothetical connection speed, useful for understanding the scale. A 4.58 GB transfer on the same connection would take more than 12 minutes. People may make that download once if the application can cache it. A user who skips a feature on the first launch may never discover how fast it feels once it is ready. Installation, initial load and warm response time deserve separate measurements.

A public download is only one part of a dependable local experience. A web application may need to manage network interruptions, the browser’s available storage and model versions in a cache. Native apps have similar deployment concerns with a different set of OS rules. A managed organization may distribute the model on a local network or as part of an application update. Each choice affects which devices can start work immediately and which have to retrieve files before use. ONNX Runtime’s web documentation discusses file sizes, memory and external data when working with large models. A smaller artifact makes the design more plausible. It still calls for a first-run experience that reflects the actual transfer and initialization. ONNX Runtime on large web models

A compatible device has several things to do at once. It loads and prepares the model, consumes the input, then generates output in a loop. A laptop with a discrete GPU, one that reserves system memory for graphics and one relying on a different provider may all report very different speed and memory behavior. Microsoft’s preview sample also describes cold compilation for neural accelerators and reuse of caches afterward. Those are properties of its preview path, with its particular prerequisites. A fair timing exercise should log the model version, device, runtime, input length, time to the first output and time to finish. A single rate measured after warm-up will leave out several costs that shape daily use. Microsoft’s Aion preview sample

There is also an ongoing cost, even when an application avoids a request charge. Local work uses storage, memory, electricity and part of the machine’s processing capacity. On a plugged-in workstation, those costs may be barely visible. A reader reviewing long documents on battery may feel them as a fan spinning up, a warmer device or less remaining charge. It helps to choose features where the savings in connection time or access to an offline capability matter to the user. A useful evaluation could track whether the application remains responsive during a summary, how often other work is interrupted, and whether repeated tasks justify a model kept on the device.

This is why application size and model size can guide different decisions. A team shipping a 20 MB utility can offer a 1.3 GB model as a separate selected capability, with progress and a clear way to use the rest of the program before it arrives. A dedicated research application might include the weights in a managed desktop deployment because organizers know its users will need them. Both can run the same model. The difference is how often the local feature returns enough value to justify the installation, how the team can move to a compatible version and what happens when disk or memory is scarce.

Context length is a ceiling for tokens#

The main card lists a context of 32,768 tokens. The WebGPU package says its default generation setting is 4,096 tokens for the prompt and generated text together. Its configuration can be raised to the larger model limit, with a bigger pre-allocated cache. A flow that absorbs a long document has to reserve room for its own instructions and the result, and it has to fit at the runtime level. Tokens are pieces of the input, not word or page counts. Two documents of similar length on screen can require different capacity depending on language, tables and textual structure. The specification sets an upper bound, and the deployment chooses how close the user can get to it. Context and WebGPU configuration

Consider a twelve-page report with a budget table and warnings attached to four recommendations. A reader wants a concise brief that preserves every warning and the relevant amount. An application can grade whether the warnings made it into the answer, whether the numbers are faithful and whether the reported source passages support them. This evaluates more than whether the prompt stayed under the input limit. A model can take a document and still miss a detail in the middle. The result also depends on how the application converts files to text. If a table becomes a block of unlabelled numbers during that conversion, a larger context window will leave the model with the same ambiguity.

Different features can make good use of different input shapes. A rewrite usually needs a selected passage and instructions about tone. A meeting summary needs names, decisions and locations in the transcript to check them. A question about a long handbook can benefit from pulling a few relevant passages into the input and showing those passages to the reader. Shortening the material can save memory and help the model focus. It is worth recording whether the feature is doing a full-document or retrieved-passage task, because a mistaken retrieval and a mistaken generated sentence require different fixes. Both mistakes surface to the reader as a bad answer.

The December 2025 knowledge cutoff in the model card is also important. At this publication date, the released model cannot be expected to have learned every subsequent event from training. A local document can supply current facts, and an application may provide an explicit lookup where that fits its privacy model. A question about today’s price or the latest policy is a different task from rewriting the policy text already in view. A product can reduce mistakes by telling the reader when its result is based on an open document and showing the underlying passage. General fluency is easy to see, while whether the answer knows its source takes a deliberately designed test. Model overview and cutoff

What the published tests support#

Microsoft reports 55.15 on MMLU, 83.90 on its reported strict IFEval average and 32.00 on the loose prompt-level measure for IFBench. These are different tasks with different metrics. The results help identify what may be worth testing, from general knowledge to following a set of instructions. They do not establish how often a particular application will meet its quality threshold. Microsoft also lists limitations for factual detail and complex reasoning. The WebGPU card says comparative quality figures for the quantized version are still to come. A team shipping that version should study the outputs of that version on the documents it plans to support. Microsoft’s reference evaluation · WebGPU evaluation notes

The same caution applies to languages. Microsoft names eight languages, including English, French and Chinese, and says quality can vary by language. Russian is outside the eight listed. For a rewriting tool, an appropriate test set might contain ordinary messages, specialized vocabulary, bilingual names and examples with explicit constraints on tone. For a summary tool, it could include tables and names the reader must be able to recognize. When teams use only polished examples in one language, they can miss how a smaller model handles real punctuation, abbreviations or mixed-language text. A useful result gives the user a clear account of what the feature reliably supports. Supported languages and limitations

Comparing the four-bit and unquantized versions also takes care. Lower-precision weights shrink the file. Under the same inputs, they can change output quality or the model’s response to formatting instructions. The hardware and runtime can change latency independently of the model’s answer. A limited evaluation could use the same prompt, stop conditions and examples across the two packages, then separately compare time to first output, peak memory and the proportion of answers people can use without editing. For rewriting, omissions may matter more than style. For structured extraction, output shape and retained facts might be more important. The smallest usable package is an empirical choice for the readers and devices served.

There is a related engineering issue for the main download. Microsoft’s card describes a Transformers setup using custom repository code. Downloading the model and running code from a repository are separate operations. Teams using the release in a managed environment can select a known revision, examine the runtime dependency and compare that package with a supported ONNX route before handing it to users. This is ordinary software supply-chain work. It is also an application-quality matter. A model advertised as local may still need dependencies and assets during installation. If a feature promises use without a connection, it needs to demonstrate the complete offline run after those pieces are already present. Main model’s runtime notes

Local processing changes where responsibility sits#

The privacy benefit of a local pipeline is concrete when the document is read, processed and returned on the machine. The model host then has no request to handle. That says little about the rest of the application. A document reader might sync original text to an account, a diagnostics service might record excerpts, or a hybrid feature might offer a remote model when the device cannot finish. Those are design choices that affect what goes out. Users need understandable behavior when a device lacks memory, the model has yet to download or service quality is low. A clearly described local mode becomes valuable when the application can show which routes it used and what files it stored.

One practical check is to open a document that contains synthetic text, complete the initial download, disconnect the device and repeat the same request. The result can show whether the feature is usable in the circumstance it promises to handle. Reconnecting and signing out can reveal other boundaries, such as whether storage is tied to an account or whether a local result is queued for synchronization. A user should be able to tell which features are available before a download and how to remove the files later. These details matter when the same product supports local and hosted processing. They let customers understand what they have enabled without having to understand a runtime’s implementation.

A predictable integration also has to consider the difference between open weights and Windows’ planned guardrails. Microsoft says the model it intends to put into Windows will be paired with a local moderation model. Developers using the separate downloads have to evaluate the actual components they include and the impact of the task on their users. Drafting a summary for review is a simpler scope than automatically forwarding it. For a private note, the person reading the draft can check fidelity and revise it. If another system treats the responsible-looking prose as an instruction, the consequence changes. Keeping generated text a proposal in early deployments can make it straightforward for users to learn where the model is helpful.

Workflows that use a local model can still call conventional application features. The important distinction is who initiates an action and how it is authorized. A text assistant can suggest a title and let the reader apply it. An accessibility app can generate a plain-language explanation and keep the source available. A note taker can label possible decisions for human confirmation. These are useful designs because an imperfect answer remains easy to inspect. Measuring how often the model produces an acceptable result on the first attempt will be more informative than describing it as a full assistant. The product can add more responsibilities when it has observed how the initial ones work.

The release’s permissive license helps application teams distribute and study the published package within its terms. The model card also offers advice about uses and limitations. The operating-system distribution has its own delivery process, and the preview framework documents terms for its particular validation package. Before treating the preview, open weights and future Windows API as one component, a team needs to identify which component it plans to put into a product and which update mechanism will maintain it. Tracking that choice reduces surprises when the downloadable package remains at a known revision but a system provider evolves. Weights license · Windows preview package documentation

The Windows transition deserves its own test#

Microsoft says applications using familiar Windows AI APIs will generally need little change during the transition from Phi Silica. It calls out custom prompts, custom LoRA adapters and specialized parsing as areas that should be checked, including invisible watermarking for certain regional text-provenance requirements. A team depending on the old model’s exact phrases may see changed behavior even if its API calls still succeed. The right comparison involves the outputs and the client workflow, including how the application recovers from unexpected text. An app that uses structured output may want to keep a set of difficult examples from both models. Microsoft’s migration details

Timing matters here because users’ devices may update at different moments. An organization can have some machines on the old local model, a smaller group in a preview and others already moved after general availability begins. Recording the runtime and version in internal quality measurements can show whether a change tracks a particular group. Applications can maintain a narrow, well-tested baseline for both versions during the transition. A deployment that assumes a model switch will occur simultaneously across all devices will be hard to debug. Microsoft’s stated targets help schedule a pilot and preserve time to adjust prompts and parsing once the retail version becomes available. Windows AI model documentation

The release therefore makes it unusually straightforward to begin a realistic trial. Start with a text task that matters on a device users already have, choose the package they could actually install and check answer quality and response under warm, cold and disconnected conditions. Track what happens in languages the application promises to serve. Record where it obtained the model and what it sends elsewhere. If the answers are dependable, the browser or native package can give that one task a useful on-device path. The Windows schedule gives another route to evaluate when it reaches the relevant machines. The most interesting result will be a feature whose users keep choosing it after the convenience of local processing has to compete with the costs of running it.