Opera has started shipping WebAI, a proposed web standard that lets websites and browser extensions use AI models that run on your own computer instead of a cloud service. In its October 27, 2026 announcement, the company says it "today began shipping local AI models in its browsers," starting with an early preview in Opera One. TechCrunch reported that the first models are Google's Gemma and, on Macs, Apple's on-device foundation model.
For anyone building with local models, the interesting part is not the browser. It is the idea that a web page or extension could ask the browser for "a local model" the way it asks for geolocation or the camera, with the user in control. This post covers what Opera confirmed, what is still missing, how it compares with what you can already do, and what to test first.
TL;DR: the questions people will ask
| Question | Short answer |
|---|---|
| What is it? | A proposed web standard for sites and extensions to use on-device AI models |
| Who announced it? | Opera, on October 27, 2026 |
| Which models? | Google Gemma; Apple's on-device foundation model on Macs; more promised |
| Is it on by default? | No. Opt-in, and no model downloads until you enable it |
| What can it do? | Generate text, classify content, find relationships between pieces of information |
| Where does it run first? | Opera One (early preview); Opera GX and Opera Neon later |
| Is it a finished standard? | No. It is a proposal, backed by companies including Google and Microsoft per Opera |
| Is there a public spec? | Not in the launch coverage we could read |
What Opera actually announced
According to coverage of Opera's release, WebAI lets websites and extensions use models that run on the user's device. CyberInsider's summary lists three capabilities: text generation, content classification, and identifying relationships between pieces of information. Opera's own examples of what developers could build include extensions that organize tabs, flag clickbait, or highlight relevant job listings.
Opera also released sample extensions to help developers get started. One of them turns an article into an animated visualization by grouping sentences with similar meanings, which is a good hint at the kind of task WebAI targets: small, private, repeatable jobs on text the user already has open, rather than open-ended chat.
The preview is off by default. Opera says no model is downloaded until the user enables it, and that separate permissions decide which sites can reach the local models. Reports say it runs on 64-bit Windows and on Apple silicon Macs, with performance depending on the hardware, and no rollout timetable for Opera GX and Opera Neon.
TechCrunch quotes the developer pitch: developers can add AI features "without running AI infrastructure or paying for every request." That line is the real business case, and we come back to it below.
Which models, and why Apple's is the surprise
Gemma is the expected choice. Google's open-weight family is small enough to run on ordinary laptops, and Opera has had Gemma in its local-model experiments since its April 2024 developer-stream release, which offered 150 model variants through the Ollama framework. That earlier work needed 2 to 10 GB of storage per variant and was labelled experimental. WebAI looks like the productized version of the same idea, now with a proposed API surface instead of a model picker.
The surprise is 9to5Mac's report that Mac users can run Apple's on-device foundation model directly in Opera One. That means a third-party browser reaching a model Apple ships with the operating system. The report does not say which macOS version is required or how to switch it on, so check Opera's own documentation before assuming your machine qualifies.
Opera describes the implementation as model-agnostic and says it plans to add more open models. If that holds, the same extension code could run against Gemma on a Windows laptop and Apple's model on a MacBook, which is exactly the portability a standard is meant to give.
Local AI model running inside a handheld device cutaway, illustrating on-device WebAI processing
What is claimed vs. what is verified
Because this is a day-one launch, it helps to separate the layers.
Confirmed by Opera's release and multiple outlets: the name WebAI; the early preview in Opera One; Gemma and Apple's model as launch options; opt-in behavior; per-site permissions; sample extensions; Opera GX and Neon to follow.
Claimed by Opera, not independently checked: that WebAI is "supported by companies including Google and Microsoft." We could not find a statement from either company, a public specification, or a standards-body repository in the launch coverage. Treat "proposed standard" as a vendor proposal until a spec and a working group exist. Compare with earlier browser AI APIs, which went through incubation groups and shipped first in a single browser.
Worth verifying yourself: Opera, TechCrunch, CyberInsider and 9to5Mac all describe on-device processing, but this is a day-one preview, so watch network traffic when you try it.
Not stated anywhere we looked: the actual JavaScript API, model sizes and download footprint, benchmarks of speed or quality, and any commitment from other browser vendors.
Why local AI in the browser matters
Three things change when a browser exposes models as a platform feature.
Cost moves off the developer. A site that summarizes or classifies text today pays an API bill per request. If the user's machine does the work, an indie developer can ship that feature with no inference budget. The trade is that quality is capped by a small local model, and results vary per device.
Privacy gets a better default, not a guarantee. Text never has to leave the machine for the model call. But, as Opera itself notes, a site or extension can still log, upload or sell what it reads. Per-site permissions are the control that matters, so read that prompt the way you would read a camera prompt.
Distribution gets simpler. Today, shipping a local model in a web app means bundling weights, wiring WebGPU or WASM, and handling downloads yourself. We covered how fragile that path can be in our browser RAG test of small language models, where small models in the browser were checked for faithfulness. A browser-provided model removes the packaging problem and leaves the quality problem.
How it compares with what you do today
| Approach | Where it runs | Developer cost | Main catch |
|---|---|---|---|
| Cloud API call | Provider servers | Per-request billing | Data leaves the device |
| Bundled WebGPU or WASM model | User's device, your code | Hosting weights, engineering time | Large downloads, per-site duplication |
| Local runtime like Ollama or llama.cpp | User's device, outside the browser | None, but user must install | Setup friction; sites cannot rely on it |
| Browser-provided model (WebAI) | User's device, via the browser | None per request | One browser so far; unspecified API; small models |
If you already run models locally outside the browser, such as in the ds4 setup for high-memory Macs or on Apple silicon clusters, WebAI is not a replacement. It targets the opposite end: tiny, always-available models for web features, not frontier-class work.
Laptop with a small chip, representing Mac and Windows hardware running WebAI local models
The agent angle: Opera Neon and extensions
Opera describes itself as "a leading global browser and AI agent company," and Opera Neon is its agent browser. The announcement says Neon will get WebAI later. That points to a likely use: agents that do cheap steps, such as classifying a page or deciding whether it is relevant, locally, and only call a cloud model for hard reasoning.
This mirrors a broader pattern we have seen elsewhere. Google's AI Edge work shows how small embedding models can power local meeting notes on a Mac, and the EmbeddingGemma 2 guide walks through the on-device embedding side. DeepMind's work with Singapore on on-device scam detection with Gemma is another example of Gemma being picked precisely because data should stay on the phone.
Browser agents also raise a safety question: a page that can call a local model can also try to steer it. If you use agentic browsing, our ChatGPT Chrome extension permissions guide covers the permission model worth applying here too. For stopping agents before they take dangerous actions, see AgentBeam.
Also in the release: HTML-in-Canvas
Opera announced a second feature alongside WebAI. HTML-in-Canvas lets developers embed interactive HTML and CSS content, such as buttons, menus and forms, inside 2D and 3D scenes, which Opera pitches at games and interactive experiences, including in Opera GX. It is unrelated to local AI, but it shows how Opera is using its smaller browsers to push platform ideas that bigger vendors move slowly on.
How to try it and what to test
- Install Opera One and look for the WebAI early-preview setting. Opera's announcement says it is opt-in; we have not confirmed the exact menu path, so follow the in-browser prompts.
- Enable it and let the first model download. Expect storage use in the gigabytes range for local models generally, based on Opera's 2024 figures of 2 to 10 GB per variant, though WebAI's actual footprint is unpublished.
- Install Opera's sample extensions and read their source. That is the fastest way to learn the real API shape before any spec appears.
- Open the permission settings and confirm a site must be granted access before it can use the local model.
- Watch the network panel while a feature runs to check that nothing is sent off-device.
- Test on weak hardware too. Opera says performance depends on your machine, and a feature that feels instant on an M-series Mac may crawl on an older Windows laptop.
What developers should do now
Do not build a product on WebAI yet. It is a single-vendor preview with an undocumented API and a standard that exists only as a proposal. Do prototype: classification, tab organization, clickbait flags and similar tasks are the right size for small models, and the cost model is attractive.
Design for fallback. A feature that uses WebAI when present and a cloud call or no-AI path otherwise will survive whichever way the standard goes. And decide in advance what data your extension reads, because the permission prompt makes that your responsibility.
What to watch next
- A published specification and a named standards venue
- Statements from Google and Microsoft confirming support
- Whether Chrome, Edge, Firefox or Safari adopt compatible APIs
- Opera GX and Opera Neon release dates
- Independent speed and quality tests of Gemma and Apple's model through WebAI
- Which additional open models Opera adds
We will update this post when Opera publishes API documentation or another browser vendor responds.
Related reading
- Browser RAG with small language models: faithfulness test
- DwarfStar ds4: running big open models on a Mac
- Apple MLX over Thunderbolt 5: local inference on Mac Studio
- Google AI Edge and local meeting notes with EmbeddingGemma 2
- EmbeddingGemma 2 on-device guide
- DeepMind and Singapore: on-device scam detection with Gemma
- ChatGPT Chrome extension: permissions and risks
Details are accurate as of October 27, 2026. WebAI is an early preview and a proposal; specifics may change.