Google shipped the Prompt API in Chrome 148 on May 5, 2026. Mozilla objected. Apple's WebKit team objected. The W3C TAG objected. Microsoft Edge disabled the feature entirely despite running on the same Chromium engine. It was, by any measure, one of the most contested browser feature launches in recent memory.
And it doesn't matter. Google has already won this one.
What Actually Happened
Chrome 148 quietly gave every website on earth the ability to run AI inference locally (text generation, summarization, classification, image captioning) by talking to Gemini Nano, a 4GB model that Chrome now ships to users' devices without asking. The API is dead simple:
const session = await self.ai.languageModel.create({ systemPrompt });
const result = await session.prompt("Your prompt here");
That's it. No API key. No latency. No server cost. No data leaving the device.
The opposition's core argument is a legitimate one: unlike fetch() or addEventListener(), an AI model isn't a deterministic spec. Two browsers implementing the "same API" with different underlying models could produce wildly different outputs, breaking the foundational promise of web standards: write once, run identically everywhere.
It's a real concern. It's also, in practice, irrelevant.
The Web Has Never Guaranteed Identical Outputs
Font rendering differs across browsers. Canvas pixels vary by GPU driver. Audio processing behaves differently on macOS versus Windows. Math.random() is, by definition, non-deterministic. None of these killed the web. Developers adapted, and they'll adapt here too.
The "we can't standardize non-deterministic output" argument proves too much. If it were applied consistently, half the modern web platform wouldn't exist.
Cloud Is the Real Baseline: Not Firefox's Future Model
Here's the thing critics seem to be missing: developers building serious AI features today aren't choosing between Chrome's Prompt API and Firefox's theoretical equivalent. They're calling cloud APIs: OpenAI, Anthropic, Gemini Cloud. Those are where the quality is, where the context windows are, where the capable models live.
Gemini Nano is a small model. It's good at lightweight, well-scoped tasks: summarizing a paragraph, classifying sentiment, extracting a date from a string. It's not replacing GPT-4o or Claude Sonnet for anything that actually matters.
So the Prompt API isn't competing with cloud AI. It's filling a specific niche:
- Zero latency tasks that need to feel instant
- Offline-capable features in PWAs
- Privacy-sensitive processing where data must stay on device
- Cost-sensitive at-scale operations (spell check, auto-tagging, content filtering)
Developers will reach for it as a progressive enhancement layer: use the Prompt API when available, fall back to a cloud call when not. The non-determinism objection collapses entirely in this framing: nobody is relying on Chrome and Firefox producing the same tokens. They're relying on "good enough local inference" vs "cloud inference." That gap is fine.
We Have Seen This Movie Before
PWAs. Web Components. Service Workers. WebRTC. Each time, the pattern is the same:
- Google ships something useful but contested
- Mozilla and Apple raise principled standards objections (sometimes valid, sometimes a proxy for business interests)
- Developers adopt it anyway, because Chrome is 65% of global browser traffic
- The holdouts implement their own version 2–5 years later
- It retroactively becomes a "web standard"
PWAs are the sharpest example. Apple resisted for years: not primarily because of standards purity, but because native apps and the App Store are a multi-billion dollar business. They eventually shipped, incompletely at first, then more fully as the pressure became undeniable. Web Components took a similarly winding road: Google and Mozilla aligned early, Apple dragged its feet, and today Custom Elements and Shadow DOM are universally supported.
The Prompt API will follow the same arc. The only open question is how long the lag is and what compromises get made along the way. (My guess: Firefox and Safari eventually ship something with a compatible API surface but their own models underneath. Mozilla with something open-source, Apple with something Core ML-optimized. The outputs will differ. Nobody will care.)
The Real Concern Nobody Is Saying Out Loud
Apple's strategic worry isn't about spec compliance. It's about this: Google just normalized the browser as an AI delivery vehicle and installed its model on over 4 billion devices. That's not a web standards problem. That's an ecosystem control problem.
Whoever controls the model layer of the browser controls a significant surface area of how users interact with the web: what gets summarized, how content gets classified, what gets surfaced and what doesn't. Apple understands this better than anyone; it's exactly the kind of leverage they've built with the App Store for 15 years.
That's a legitimate concern worth having a serious conversation about. But dressing it up as a standards integrity argument dilutes it and, frankly, makes the objectors look like they're arguing in bad faith. That weakens their position when the real fight (model governance, content policies, on-device data access) eventually arrives.
What This Means for You
If you're building web products today:
Developers: Start experimenting with the Prompt API now for lightweight, latency-sensitive tasks. Design with graceful degradation: the API isn't available in Firefox or Safari yet, so treat it as enhancement, not baseline. WebGPU-based bring-your-own-model approaches (via transformers.js, ONNX Runtime Web) remain the cross-browser story for anything more demanding. If you want a unified abstraction over both, check out web-ai-sdk.dev.
Product and business: The interesting unlock here isn't replacing your cloud AI pipeline. It's enabling AI features that previously couldn't exist on the web: instant, offline, private, zero marginal cost. Think client-side content moderation, on-device personalization, local draft assistance. The economics and privacy story are genuinely new.
The browser is becoming an AI runtime. Google didn't ask for permission. That ship has sailed.
The Prompt API is available in Chrome 148+. WebGPU-based inference works cross-browser today via libraries like Transformers.js. WebNN remains experimental across all browsers.