Mozilla Says No: Why Chrome's Built-In AI API Is 'Harmful' to the Web

What Happened

Mozilla has formally designated Google's Prompt API — the centerpiece of Chrome's "built-in AI" initiative — as harmful in its standards-positions repository, the canonical place where Mozilla records whether it supports, opposes, or remains neutral on proposed web standards. The filing at [mozilla/standards-positions#1213](https://github.com/mozilla/standards-positions/issues/1213) drew over 600 upvotes on Hacker News and reignited a fundamental debate about what belongs in the browser platform.

The Prompt API, part of a broader suite of on-device AI APIs Google has been developing under the Web AI umbrella, would let developers call something like `const session = await ai.languageModel.create()` and then `session.prompt('Summarize this article')` directly from JavaScript — no API keys, no network requests, no billing. Chrome ships Gemini Nano on-device to handle inference. Google has been testing these APIs behind origin trials and flags since mid-2024, and the intent-to-ship signals were growing louder.

Mozilla's position effectively blocks the Prompt API from becoming a cross-browser web standard, which is the only path to it becoming a feature developers can rely on. Without buy-in from at least two major engines, the W3C standardization process stalls. Safari/WebKit has not published a formal position, but the silence is not encouraging for Google.

Why It Matters

The disagreement isn't cosmetic — it's architectural, and it cuts to a 25-year-old question about what the web platform is for.

Mozilla's argument rests on interoperability, the foundational principle of web standards. When you call `document.querySelector()`, you get the same result in Chrome, Firefox, and Safari. When you call `fetch()`, the response is deterministic given the same server. The Prompt API breaks this contract fundamentally: the same prompt, on the same page, would produce different text depending on which browser the user is running and which model version that browser happens to bundle. Mozilla argues this isn't a web standard — it's a vendor-specific feature wearing standards clothing.

Mozilla engineers have pointed out the practical consequences: if a developer builds a feature on the Prompt API and tests it against Gemini Nano's outputs, that feature may behave unpredictably on any browser that ships a different model — or simply not work at all on browsers that decline to bundle a multi-gigabyte LLM. The "standard" becomes a de facto requirement to ship Google's model, or one compatible with it. That's not interoperability; that's a monoculture.

Google's argument is equally substantive. On-device AI is a privacy win — user data never leaves the device. It eliminates the API-key-and-billing barrier that currently limits AI integration to well-funded apps. Latency drops from hundreds of milliseconds (cloud round-trip) to single-digit milliseconds. And the use cases are real: smart compose, content summarization, translation, form assistance, accessibility tools. Google contends that the web platform must evolve to include AI capabilities or risk losing developers to native platforms that already offer them.

Google has also argued that non-determinism is already present in web APIs — `Date.now()` returns different values, `Math.random()` is non-deterministic, and even CSS rendering varies subtly across engines. The Prompt API, they suggest, is a natural extension of this spectrum.

The community is split but leans toward Mozilla. The Hacker News discussion (606 points) reveals a developer base that is sympathetic to the promise of on-device AI but deeply skeptical of the standardization approach. The most upvoted comments echo Mozilla's interoperability concern and raise additional ones: the forced download of multi-gigabyte models on resource-constrained devices, the update cadence problem (model updates changing app behavior), and the philosophical question of whether probabilistic outputs belong in a deterministic platform specification.

Some developers have pushed back on Mozilla's position, arguing it's overly conservative — that Firefox's declining market share means Mozilla is effectively using its standards veto to block innovation it can't match. This is an uncomfortable but not unfounded critique. Mozilla does not have the resources to train and ship competitive on-device models, which creates a conflict of interest in its standards position.

What This Means for Your Stack

If you're building AI features into web apps today, the practical guidance is clear: do not build production features on the Prompt API or any `window.ai` surface. It is Chrome-only, it has no standards track, and a major browser engine has formally opposed it. Building on it means building on a proprietary Chrome extension that could be deprecated, altered, or abandoned.

Instead, use the established pattern: call AI services from your backend (or from the client via API keys to services like OpenAI, Anthropic, or Google's own Gemini API). Yes, this means cloud round-trips and billing. But it also means your feature works identically in every browser, you control the model version, and you can test deterministically.

If you're interested in on-device AI for legitimate privacy reasons — medical data, financial information, offline-first apps — watch the WebNN (Web Neural Network) API and ONNX Runtime Web instead. These operate at a lower level of abstraction (tensor operations, not natural language prompts), which makes interoperability achievable because the inputs and outputs are numerical, not linguistic. WebNN has a much clearer path to cross-browser adoption precisely because it avoids the "which model" problem entirely.

If you're a framework or library author, resist the temptation to add Prompt API adapters. Every abstraction layer built on a non-standard foundation is technical debt with a timer on it.

Looking Ahead

This isn't the last round. Google has significant leverage — Chrome's 65%+ market share means a Chrome-only API still reaches the majority of users, and Google may decide to ship it regardless of standards consensus, as it has done before (see: Web Bundles, various AMP-adjacent proposals). The question is whether developers will adopt a Chrome-only AI API or wait for something cross-browser. History suggests developers are pragmatic enough to use what works — but also burned enough by vendor lock-in (Flash, ActiveX, early IE extensions) to be cautious. Mozilla may be losing the browser war, but on this particular standards fight, the technical argument is on their side.