Opera announced on October 27, 2026 that it is now shipping local AI models directly in its browsers. The first capabilities are live as an early preview in Opera One, with Opera GX and Opera Neon to follow.
Here's the part that matters if you build things for the web: the headline capability is WebAI, a proposed web standard backed by companies including Google and Microsoft, that lets websites and browser extensions use AI models hosted through the browser itself.
Read that again, because it changes the economics of a whole class of product. An extension that sorts your tabs, flags clickbait, or spots relevant job posts can now do it with a model running on the user's own computer. No API key. No per-request bill. No account, no fee, and no data sent to an AI service.
Opera's EVP of Browsers and AI, Krystian Kolondra, put it plainly: "A lot of what people want from AI doesn't need a data center. Your laptop can already do it, without sending your data anywhere."
What is actually shipping today
Let's be precise, because "local AI in the browser" can mean a lot of things and most of them are demos.
What Opera shipped on October 27 is an early preview, not a finished platform:
- WebAI, as an opt-in early preview in Opera One. Nothing is downloaded until the user turns it on, and site-specific permissions control which websites can access local AI.
- Model-agnostic, built around open models. At launch, users can use Google's Gemma models and, on Macs, Apple's on-device foundation model, directly in Opera.
- Available on 64-bit Windows PCs (Intel or AMD) and Macs with Apple silicon. Because the model runs on the user's own device, performance depends on their hardware. That's not a footnote — it's the whole trade-off.
- What WebAI can do today: generate text, classify content, and understand how pieces of information relate, all directly in the browser.
This is not Opera's first step here. Opera was the first major browser to offer built-in access to local AI models, in an experimental developer build back in 2024. This launch takes that work out of the developer build and into everyday browsers. That's the real news: local AI graduates from experiment to product.
Opera is also releasing example extensions to show developers what's possible, including one that turns an article into moving art, where similar sentences become visual neighbours.
Why this changes the math for extension developers
Think about how a typical AI-powered extension works today. You ship the extension, and every AI feature routes through your API key to someone else's model. That means:
- You pay per request, forever, for every user.
- You need infrastructure — keys, quotas, billing, abuse handling.
- Your users' data leaves their machine and goes to your server, then to a model provider.
- The moment your free tier gets popular, your bill explodes and you either start charging or start degrading the feature.
WebAI flips all four. The model runs on the user's machine. There is no per-request cost to you, because there is no request to a service. There is no data leaving the device. And the user stays in control of what runs on their computer — Opera says users will always decide what runs on their machine.
That doesn't make every AI feature free. The user still pays in hardware — a model running locally uses their CPU, memory, and battery, and performance will vary a lot between a new Apple silicon Mac and a five-year-old Windows laptop. But it removes the single biggest reason small developers don't ship AI features: the fear that success will bankrupt them.
If you've ever had an idea for a browser extension that was "too AI-expensive to give away for free," this is the announcement that makes it viable. A tab organiser, a clickbait detector, a job-post spotter, a reading summariser — Opera's own examples, and all of them are features that only need a small, capable model, not a frontier one.
The honest caveats
I don't want to oversell this, because the preview status matters:
- It's an early preview. WebAI is a proposed standard, not a ratified one. The API surface and model support will change.
- Opera One only, for now. GX and Neon are promised, not shipped. And this is Opera — Chrome, Edge, and Firefox haven't shipped the same thing yet, so you're building for one browser's users today.
- Model choice is limited at launch. Gemma and Apple's on-device foundation model. Good starting points, but not the whole open-model ecosystem yet. Opera says more models and tools are coming.
- Performance is hardware-dependent. On-device AI on a weak machine will be slow, and your extension needs to handle that gracefully — fallbacks, progress states, and honest expectations, not a spinner that never ends.
- Privacy is better, not absolute. Data stays on the device, which is a genuine improvement over sending everything to a cloud API. But the extension itself still sees the page content it processes, so your privacy story still depends on what your code does with it.
The right way to think about WebAI today: it's a real, shipping preview of a plausible future where the browser is an AI runtime, not just an AI client. Worth experimenting with now; not yet something to bet a business on exclusively.
Also launching: HTML-in-Canvas
Alongside WebAI, Opera launched HTML-in-Canvas, which puts live, interactive web pages inside 2D and 3D scenes — menus, buttons, and forms that move with the scene and still work, built with the HTML and CSS developers already know. Opera's demos include Webpage Bulldozer, where web page elements become physical objects, and Gamer Room, a 3D room with live web pages on its screens. It's a natural fit for games and Opera GX, and it's fun — but it's a side note next to WebAI, not the main event.
What to do with this
If you build browser extensions, here's the practical takeaway:
- Try the preview. Install Opera One, turn WebAI on, and run Opera's example extensions. Feel what on-device latency actually feels like before you design around it.
- Prototype the feature you couldn't afford before. The tab sorter, the classifier, the summariser — the one you shelved because the API bill scared you. Local AI is the version of that idea that can stay free.
- Design for variable hardware. Assume the model is slow on some machines. Make your feature degrade gracefully, and be honest in your extension listing about what it needs.
- Watch the standard, not just Opera. WebAI is backed by Google and Microsoft as a proposal. If it gains traction across browsers, the browser-as-AI-runtime idea becomes platform-level, and early experience with it becomes a real advantage.
The browser has spent thirty years being a window to someone else's computer. WebAI is a small, concrete step toward it being a computer of its own — one that runs AI without asking a data center for permission, and without sending your data anywhere to do it.
That's worth paying attention to, even in preview.
Source: Opera newsroom, "Opera adds local AI to its browsers," October 27, 2026 — https://press.opera.com/2026/10/27/opera-doubles-down-on-local-ai-shipping-models-directly-in-its-browsers/ — and Opera's WebAI developer post at next.opera.com/blog/web-ai-local-ai/. All facts above are from Opera's announcement; the quote from Krystian Kolondra is verbatim from that announcement. No affiliate links in this article.
Top comments (0)