Chrome 131 shipped with Gemini Nano built into the browser. You can now call AI directly from JavaScript:
const session = await ai.languageModel.create();
const response = await session.prompt("Explain quantum computing");
This is significant. It's also concerning.
Google just made "browser AI" a category. But they defined it as "Google AI"—locked to Gemini, controlled by Google, with no user choice.
What Chrome 131 Actually Shipped
Summarizer API:
const summarizer = await ai.summarizer.create();
const summary = await summarizer.summarize(longArticle);
Language Model API:
const session = await ai.languageModel.create();
const result = await session.prompt("Write a haiku about coding");
Translation API:
const translator = await ai.translator.create({
sourceLanguage: 'en',
targetLanguage: 'es'
});
const translated = await translator.translate("Hello world");
What these share:
- All powered by Gemini Nano
- All controlled by Google
- No user choice in provider
- No local-only option (telemetry and data practices unclear)
The Technical Lock-in
Let's be specific about what's locked:
Model Lock-in
You get Gemini Nano. Period.
- Can't use Claude: No
- Can't use Llama: No
- Can't use Mistral: No
- Can't use local Ollama: No
API Lock-in
The API is Chrome-specific:
// Chrome only
const session = await ai.languageModel.create();
// Other browsers: "ai is not defined"
There's no spec. There's no cross-browser compatibility. Code written for Chrome's AI won't work anywhere else.
Update Lock-in
Google controls when Gemini Nano updates. Your app depends on Google's release schedule.
- Model improves? Google decides when.
- Model regresses? You have no recourse.
- Model changes behavior? You find out when users report bugs.
Historical Parallels
We've seen this pattern before.
Flash vs. Open Video
2000s: Flash was the only way to do video on the web. Adobe controlled everything.
Result: HTML5 <video> replaced Flash with an open standard. Took years, but the web won.
Parallel: Chrome AI is the new Flash. A proprietary solution that works, but locks the web to one vendor.
IE6 vs. Web Standards
2000s: Internet Explorer had 95% market share. Developers built for IE only.
Result: Web standards movement pushed back. Took a decade, but open standards won.
Parallel: Chrome has 65% market share. "Chrome-only AI" could become the new "works best in IE."
Flash Cookies vs. Local Storage
2000s: Flash LSOs were the only way to store significant data client-side.
Result: localStorage and IndexedDB replaced proprietary storage with standards.
Parallel: Chrome's AI storage (model caching, conversation state) is proprietary. Open alternatives need to exist.
What Google Gets Out of This
Google isn't shipping browser AI out of altruism. The incentives:
1. Data flow
Every Gemini Nano query teaches Google about usage patterns. Even if the model runs locally, telemetry about what users ask is valuable.
2. Ecosystem lock-in
Apps built on Chrome AI won't work elsewhere. This keeps developers on Chrome.
3. Gemini adoption
Making Gemini the default browser AI normalizes Google's AI. Users associate "AI" with "Google."
4. Competitive moat
Other browsers can't easily replicate this. Google has the models, the infrastructure, and the market share.
What the Open Web Needs
The alternative isn't "no browser AI." The alternative is "open browser AI."
A Standard API
// Proposed: navigator.llm
// Works across browsers, user chooses provider
if ('llm' in navigator) {
const response = await navigator.llm.prompt("Hello");
}
This would be like navigator.geolocation—a standard capability that works the same everywhere.
User Provider Choice
Browser Settings → AI Provider:
┌────────────────────────────────────┐
│ ○ Gemini (Google) │
│ ● Ollama (Local) │
│ ○ Claude (Anthropic) │
│ ○ OpenAI (GPT-4) │
└────────────────────────────────────┘
User decides. Not Google. Not the website.
Cross-Browser Compatibility
A specification that:
- Chrome implements (they'd probably still default to Gemini)
- Firefox implements (with user choice)
- Safari implements (with Apple Intelligence integration)
- Brave implements (they already have BYOM)
Same API, different implementations, user control.
Privacy Options
// User preference: "always local"
const response = await navigator.llm.prompt(input);
// Routes to Ollama, never leaves device
Users who want privacy get privacy. Users who want cloud get cloud. User decides.
The Current Situation
Chrome (65% market share): Gemini Nano, no choice Safari (18% market share): Nothing Firefox (3% market share): Nothing Brave (~1% market share): Leo with BYOM Edge (~5% market share): Copilot, Microsoft-controlled
Only Brave offers user choice. But Brave's approach isn't a standard—it's a feature.
What Developers Should Do
Don't Build Chrome-Only
// Don't do this
const session = await ai.languageModel.create();
// Your code only works in Chrome
// Do this
if ('llm' in navigator) {
const response = await navigator.llm.prompt(input);
} else {
// Fallback or graceful degradation
}
Build for standards. If standards don't exist yet, build for polyfills that implement standard patterns.
Support User Choice
If you must use AI, give users options:
const providers = {
openai: () => callOpenAI(input),
anthropic: () => callAnthropic(input),
ollama: () => callOllama(input),
browser: () => navigator.llm?.prompt(input)
};
// User selects in settings
const response = await providers[userChoice]();
Design for Graceful Degradation
async function getSmartSuggestions(content) {
// Best: User's AI
if ('llm' in navigator) {
return await navigator.llm.prompt(`Suggest improvements: ${content}`);
}
// Fallback: Server-side
if (serverAIEnabled) {
return await fetch('/api/suggest', { body: content });
}
// Graceful: Feature works without AI
return null;
}
Don't make AI required. Make it an enhancement.
The Stakes
If Chrome's approach wins:
- Google controls browser AI
- Web apps are locked to Chrome
- Users have no choice
- Open web loses another battle
If open standards win:
- Users choose their AI
- Developers write portable code
- Competition happens on model quality
- Open web remains open
We've been here before with Flash, with IE, with proprietary APIs. The open web won those battles.
This one isn't decided yet.
This analysis is part of our series on browser AI standards. For the positive vision, see The Case for navigator.llm.