Mozilla's opposition to Chrome's Prompt API
github.com
github.com
From https://github.com/mozilla/standards-positions/issues/1213 :
"A personal example: I created a system prompt for creating announcements for a home automation system. The Gemini model I was using initially responded in a very US-American way, which didn't fit the British voice of my speaker. I told the model, via the system prompt, that the output was being spoken in a British voice, but the result was a bad US-American impersonation of British ("a'waight guv'nor apples and pears" etc etc), so I had to iterate further to 'tone it down' and speak actual British.
In this process, the system prompt becomes tailored to the model. Other models will have different quirks. Things added to the system prompt for one model may be an overcorrection for another."
Different models are just a core aspect of how the technology works.
It's like a canvas can have different possible width and height depending on the device or it's orientation. Or the geolocation API giving more or less accuracy depending on the device. Or Speech Synthesis sounding different depending on the device.
This is really just anti-AI sentiment rather than being constructive.
For now, it needs a permissions UI if it doesn't already have one. And maybe at some point they will add a n IQ level like low, medium, high or something. But developers are going to rely on the specific model 90% of the time anyway if they care about it.
What's going to change is really just that the AI hatred will die down some as people realize how much it helps them, and people will realize not having this feature in Firefox is a failure for personal data autonomy.
And the TOU that are related in Chrome being problematic is an argument FOR Firefox to add this feature, without problematic model terms.
Why exactly couldn't models, iq levels, tuning and system prompts be interchangeable in an API for this? Why not let users and devs pick which model to bring or point to one they're paying for, or what have you?
I don't see a world where 90 percent of users of this API pick the same underlying model. It doesn't seem like there's any kind of centralization with ai like that yet.
sounds like adversarial mode mocking
This API is a neutral party and can be iterated on. These objections are particular objections, to an implementation detail. One that can be swapped out, iterated on, improved on, changed, tailored to the user, by the user working with their user-agent and the LLM choice. One whose failure seems in the realm of personal preference rather than fundamental or harmful or damaging. So what if the English isn't exactly to your liking for the current model? To rest the argument against on such petty matters makes my head reel.
Iterating & improving on the base model & some system prompts allowed in this spec. Rather than using the API to try to cajole this very particular behavior that Jake seems to want everywhere, the user agent could let him set system prompts or pick a more suitable UK trained model, if that's really so important to them. The user agent is the proper channel for the agency Jake is seeking here. Theres nothing preventing the user & their user agent from negotiating what model they use. I don't think we all should be held hostage to naysaying by people who decide that the ability to have "the model needs to talk like a pirate, but this model didn't do that well" decision making. That's circumstantial nonsense, blocking the user agent from being able to work with the user to extend user agency, over such a narrow concern, that must be free to iterate anyhow!!
This API is the best basis we have to allow this negotiation to happen, out of band, outside the scope of the web API offered here, by agents. It's not up to the page to define this in the first place. It's the browser, the user agent that (as always has been the case on the web) builds user agency at its offered level of customizability & complexity. Maybe not every browser offers a "speak like a pirate". That lack is not a ding on the web prompt API!
The objections as stated have no resolution. This is a forever block for all time that is aggreived because not every model is going to behave exactly predictably perfectly. And there's no possible way out of this condundrum. The grievances of this submission are that sites will try to work around this, but the greivance here is built around the assumption that all agency has to lie with the site, that it's the site's obligation to fix US vs British English, that it's the site's need to tailor the agent.
That's not feasible not possible not sensible ever. The user agent is the mediating agent between the site and the user and the agent. That is going to be a complex evolving and dynamic relationship. The "failure" Jake cites here of the site to fully sculpt the experience is unreasonable, is an anti goal. It's up to the user and the browser to shape the agent for them, not each site.
I find these objections to be deeply deeply misguided. But worse, I find them to insist in perfection. There is no direction offered, no improvement suggested. The site can't make agents perfect therefore no one gets agents. That's all this says. It's fucking bullshit and fuck this a lot.
(I love Jake and they have done so much good so so so many times, but this is an impossible situation they are creating while leaving zero space for possibility for maybe and zero leadership for how else we can do what obviously must be done. Alas I think Mozilla at large had become the anti-possible company of web standards, which is a detestable position, one I had hoped might improve, eventually.)
This isn't how it works. As the developer, you use the system prompt to set a particular personality for the chat bot. Eg, when you use an LLM in VSCode, it comes with a system prompt to make it an effective code assistant.
Now, in VSCode, you can select a different model, which is maybe where your misconception comes from. But when you select a different model, it will also use a different system prompt, designed to achieve the same personality, but tailored for that particular model.
Once you figure out why they do that, you'll understand why your position here doesn't make sense.
I believe at $LASTJOB even Azure's web GUI let you meddle with that. This isn't cast quite so deeply in stone.
That said I do think it's ok that the app developer ask for British English. My overall concern is more that concern about model behavior & expectations feel very tight & narrow across this, and I don't think the typical well defined rigor and expectations if applied will ever ever ever let LLMs on the web. I think sites see that, I think users see that. Making perfect the enemy of the good is going to doom any attempt, forever, and no progress is possible, if these are the demands. We have to be willing to accept that models are limited, especially small local ones. That's ok.
(lmk if you'd like an ai.engineer stage to do it on)
Hearing about positive personnel shift like this now gives me a bunch more optimism on this. I really hope I can go back to the days of unambiguously being in support of Mozilla and their many awesome efforts, without always having to be a bit dubious about their next (mis)step.
1) This will be a new source of fingerprinting information and this is difficult to fake to fool fingerprinting scripts, so it can be abused for "device verification". There should be no ability to "verify" a browser, and anyone should be able to emulate any browser. This is the most important point, I thought Google people are smart enough to see it.
2) LLMs use lot of memory and CPU time, for many users they would slow down their system significantly, and given current RAM prices, upgrades are very expensive. If the website relies on local model, it would work slow on cheap devices.
3) The API seems to be tailored for specific LLM like OpenAI.
4) This can be used to push competitors who do not have an AI model from the browser market - the sites would break because they will be made with expectation of having Google Gemini model and would not work with other models. For example, the sites would break in national browsers not having an AI model. There should be no "first-class" and "second-class" browsers.
The explainer claims that this would allow the user to process the data locally without sending it anywhere. But why does Google Gemini local model have "Prohobited Use Policy" then? Why should they bother about prompts and responses they never learn about?
While offline LLM access seems like a good idea, the website could use WebGPU for this without building LLM into the browser (or they could improve WebGPU for better handling ML models). Or everyone should use the same, open source, LLM.
Google just points towards the money like other bacterium and beats its flagella until it gets there. I don't know why or how anyone would EVER think Google is going to do something good for the web or humanity.
i dislike google as much as the next guy, but sometimes it can be good to remember that actual humans work at google. some of them want to improve things for people. some of them even have a conscience.
one immediate "good" that comes to mind, from google, is the project zero team.
it doesnt, if the actions are bad.
but if your blind hatred makes you think that google will not "EVER" produce something of value to the web or humanity, then you are just being obtuse.
i have already provided one example of something good that is directly attributable to google. there are several more examples, i am sure.
And, surprise surprise, the higher ups are generally the ones fucking things up because they also need to see those numbers and lines go up, regardless of actual impact on people’s lives.
So yeah, there surely are good people working for Google, but Google itself is not a person nor is it a “good” company. It is evil, end of. And, unfortunately, when you work for Satan, you don’t get to go around doing charity work.
It's inane and annoying to have to wade through the same, predictable, might-as-well-be-copy-and-paste comments on every post.
What do you have to say about the Prompt API specifically?
The momentum of the mass-entity that is Google simply cannot be overridden by some outliers trying to change direction.
Stuff like Go, Bazel, Ninja, V8, Dart, MLIR, Tensorflow, Chromium, Android, and countless others I can't remember off the top, plus their contributions to Linux, LLVM, Python, and so on... I can't think of any company that has given as much sheer volume of open source code as Google.
Hard disagree. The AI industry has absolutely shredded the various anti-scraping and anti-botting social contracts that were in place prior to the covid pandemic. Like it's now common knowledge that robots.txt isn't a hard requirement and can be avoided entirely, for example. They have absolutely turned the open web into a dark forest.
Having a browser session able to be verified as untampered and/or "trusted" is probably going to be a thing going forward. Sucks a ton, but we all did this to ourselves.
We meant who?
Anyway, just put a captcha or require a cryptocurrency payment if you are unhappy with bots, but several people unhappy about scraping are less important than billion people unhappy about tracking their activity.
Was it ever not? It's a text file, not law.
> They have absolutely turned the open web into a dark forest.
Only if you have an ideological problem with people you don't like using the things you publish on the open web.
I'd say the web can be very open even without being copyleft. It makes some business models non-viable, but it doesn't prevent anyone from publishing what they want.
On the other hand, I don't think I would call something that preserves copyright at the cost of only admitting "approved/certified non-LLM scrapers" via attestation or similar "the open web".
> Having a browser session able to be verified as untampered and/or "trusted" is probably going to be a thing going forward. Sucks a ton, but we all did this to ourselves.
Who did what to whom?
There's a broader class of concern here that reduces to the form: "The web platform should not be able to do this." For people who believe this, I think they'll invent any reason they can to push this narrative. E.g.: Well, sure, the user could turn it off, but then websites would say 'your browser isn't supported because it has no LLM' and now the web just got worse for me because I wanted to turn off LLMs.
But this reduces to "the web platform should not be able to do this" because at the end of the day it was the website operator's decision to turn off their website if an LLM is unavailable. Its not really the platform's fault, or the fault of its maintainers, that they built this capability and JP Morgan or whoever decided to screw over people who don't want to enable this feature. Similar to turning off Firefox support even though it would work fine, because they can't be assed to test their site in Firefox.
I don't know how to counter that take tbh. The web is the world's most successful application platform. It is not competing with PDF; it competes with SwiftUI. Of the options presented in front of you, you are hallucinating an option that reads like "we'll just keep the web nice and static and the way it is and nothing will ever change about it, the web is done". In reality your two options are: "We adapt the web to the evolving needs of its users" or "The web fails to serve the evolving needs of its users, and SwiftUI or WinUI steps in to fill that gap". This second option is far worse!
That immediately makes you stand out, and sites will start breaking, like now some sites (that do not do any 3D graphics) break without WebGL.
> web is the world's most successful application platform.
Also one of the ugliest and poorly designed in my opinion.
This is discussed in detail in https://webmachinelearning.github.io/writing-assistance-apis....
Are they?
[0] https://github.com/webmachinelearning/prompt-api/blob/main/R...
Operating Systems: Windows (built-in Copilot), MacOS, iOS (Apple Intelligence)
So it's >90% desktop browser and OS, plus >30% mobile OS.
Yes, I think it's very safe to say "browsers and operating systems are increasingly expected to gain access to language models."
The only people who expect them to do so are big tech executives. The average user does not expect nor want Copilot shoved into every possible corner of Windows, and Microsoft themselves have acknowledged this.
I think this API is probably fine, but only if the user already has a model downloaded and wants these features. Naturally, case in point, Chrome quietly downloads Gemini Nano without any opt-out except through group policy. Things like this and Microsoft’s recent admission that they’ve overindexed on Copilot features in Windows make it increasingly difficult to trust that users actually want more than a few killer AI features, most of which are just ChatGPT.
Anecdotally, non-technical friends and family members know about ChatGPT and increasingly Gemini, get frustrated by Copilot, and don’t know Apple Intelligence exists.
https://superuser.com/questions/1930445/can-i-delete-the-chr...
Doesn't follow. Every case you listed justifies LLM inclusion with a similar "everything is expected to be defiled by LLMs" argument, mine is a better wording but still evasively passive and the "expected" part is still nonsense.
Just don't tell me LLM inclusion is justified by "expected" all the way down, like the bottomless money pit it is.
So they should provide an interface to LLMs, disabled by default, enabled when users want it, and that’s it imho.
That also gives me the choice of which LLM provider to use, rather than being locked in whatever LLM Apple decided to do put in their OS.
I want to give Claude access to the stuff Apple Intelligence has access to, for example.
What are you trying to say?
GP is clearly asking ”Are they?”
So my question is: are browsers and operating systems really expected to gain access to language models? If so - by whom: the users or LLM vendors like Google?
I hate having to “dodge” all the AI-enabled controls my phone (iOS) is sprouting - I don’t need that shit, but there’s also no alternative.
We've seen this sort of song and dance before, crypto jumps to mind. Remember when social media sites suddenly were all about those hexagonal avatars? Most of this stuff is really in that same vein.
(Which to be clear, users don't want this. AI pushes by pretty much all recent user feedback metrics are largely tiring out users and reek of corporate desperation to sell shit. It's only a very specific subsection of Silicon Valley that wants to stuff AI in everything like this.)
A lot of these products feel unguided by an “everything must become AI” FOMO movement, rather than actual thoughtful integrations.
In theory it's useful. If devs can rely on local models, it's more private and decentralized, they don't need to funnel money to AWS or Anthropic. There are low-stakes use cases that only make sense if they're local (available offline) and free.
But in practice I've seen zero adoption of Apple Foundation Models in native apps. I wonder if any Mac/iOS devs have anything to share on this.
As for Apple foundational models, I think the issue is more that they’re just not very intelligent or good; maybe WWDC will change that; but if you want to implement LLM functionality, you’re better off either calling an API, or shipping a better small on device model.
It’s not enough for a chat-first research agent, but it’s definitely enough to unlock features that rely on natural language understanding. Seems like a small thing compared to Claude/ChatGPT and the general hype, but still magic in its own context.
I find many frustrating. I had an iphone previously and the llm summaries of text messages are what drove me to finally drop ios. I have a family member who is undergoing cancer treatment. I can't explain to you the frustration of seeing wrong text summaries when an llm goes wild hallucinating test results when the actual text simply said taking a test. OS basics and communication should be trustable. Not perhaps hallucinations of a small shitty model.
Wow. I had no idea that people would misinterpret what I was saying in this way. I was not meaning to imply it was an expectation of users or developers. I was meaning it as a statement of what was currently a growing industry trend by OS and browser vendors, of shipping or preparing to ship LMs.
By now the statement could probably be amended from "expected to gain access to" to "shipping with".
I hope the team maintaining the project now makes such an update, since apparently it's confusing so many people!
I wonder if this phrase has different connotations among other English readers? A lot of these comments are fairly early for US timezones.
"It's expected to rain tomorrow" is a prediction, whereas "students are expected to behave themselves" is an expectation (with consequences, presumably).
In the former case we clearly aren't saying we want it to rain, just that we believe it's likely, whereas in the latter example we are clearly expressing that we do want students to behave.
It's ambiguous because "expect" has two different meanings:
> to consider probable or certain
> to consider reasonable, due, or necessary
Everything is increasingly expected to gain bikesheds.
Can't wait for the CVEs.
The amount of insulting language directed at people who actually have an open mind about AI and AI tooling is frustrating. Can you all just please address the merits of the topic of the post instead of making every AI-related post on HN an excuse to vent about your own particular worldview and insult people who don't necessarily agree?
Make an AI browser extension. Done.
Shoving AI into anything where it can go is not having an open mind about things, it's nothing more shoving AI into anything where it can go.
On the inverse, can you provide a single reason why this API should exist which is isn't something that obviously erupted from an LLM? Again:
> Browsers and operating systems are increasingly expected to gain access to language models.
God help people if they have to copy their prompt from ChatGPT to Claude.
The tight coupling between prompts and models is a real concern. I deal with that every day. However: if your solution to that is to support an API that enables tighter coupling between the model the user's browser has and the prompt that gets evaluated, you will inevitably and quickly enter the domain of "You need to use Chrome to use this site (because our prompts were only tested on Gemini)" or even worse "We don't recognize the AI model you're using (because the website was written in 2026 and the current year is 2030 and they never updated it)".
This is related to the terms of use concerns the Mozilla engineer has later; real concerns. But, if we want browsers to exist that don't require users to opt-in to the terms of use of a specific AI model (e.g. using a nice open source model), its beneficial to these browsers that they can't fingerprint for the Big Models.
Of course many sites will just do an isChrome()-like call anyway. Nothing to be done about that. But yeah I am generally non-supportive of changes that introduce more ways to fingerprint browsers. The upside of keeping the model anonymous outweighs the slight downside of (rarely) encountering weird prompt evaluation output because of a small difference in behavior between Gemini and, idk, Qwen.
There are nice projects, like ungoogled chromium, tor, and many more, but I find the biggest issue is that there isn't a voice out there for the average person and a project that connects with the masses.
I think another issue is that a lot of the uninformed users have a strong apathy for the causes and ways the message is delivered, they rather engage and connect with things that are "fun" and want less friction rather than freedom and control.
How do we solve this? How do we make the browser ours, by the people, and for the people?
Sorry, I'm just sad whenever I think of this.
Simple. Break up all the big tech corporations via anti-trust legislation. They are the robber barons of our time.
Unfortunately, the answer is pretty much always "real public funding"
Your Browser Agent string isn't Chrome or Firefox? Enjoy endless Cloudflare captchas or just a 403 error.
nowadays, you could update this to just "your browser agent string isn't Chrome"
It's unrealistic to expect every app on the system to have to deal with licensing DRM themselves.
> voice out there for the average person and a project that connects with the masses
> they rather engage and connect with things that are "fun" and want less friction rather than freedom and control
Do you see the contradiction? The average person "connects with" less friction rather than control.
"We must all fear evil men, but there is another kind of evil, which we must fear most, and that is, the indifference of good men”
Followed by creating Web applications based on Web standards, instead of whatever Chrome does, and then complain about Firefox and Safari not being up to the game.
But absolutely on the second point. A standard with one implementation is not a standard. Regardless of market share, in a market with three providers, if two out of three don't support something, you have no business using it. It unhealthy for everyone involved.
If those devs cared about Web standards, it would be a pure Web application, or an headless executable, system/daemon conecting to the system's browser.
This is why Electron app devs prefer NodeJS libs to Web APIs and consequently have no impact on the adoption of a large chunk of the new Web APIs (not counting DOM and CSS things because those are rarely controversial and usually broadly implemented).
So yes, those devs don't care about these kinds of new web "standards", because they don't work with them. The people who use them are the ones who are dangerous and that's almost exclusively web app authors, because they can't just pull in a native library to do the same things.
If you were some paragon of integrity with a ton of money, developed everything yourself, and refused all corruption, you would be called the Russian Chinese terrorist child-porn browser, denounced in Congress, and eventually arrested (then released) during a layover in Germany.
Google would send an opinion to the court vaguely supporting the prosecution but disguised as technical advice; Firefox would pretend they never heard of you or what is happening, and delete all mention of you when posted in comments or on their social media. Ubuntu and Fedora would remove you from their repositories, Apple and Android never allowed you in their stores in the first place. The NYT would do a story about your "shadowy origins" and ask whether a reasonable country should allow a company so unwilling to work with the government or selected nonprofits to be an intermediary between their children and a dangerous internet. Fox would call you an Islamo-Communist anti-Semite, and somehow also associate you with the "alt-right," Dr. Fauci, and "environmental whackos."
After two years, and the banning of your project by most companies and websites, and the contrived failure of other companies simply associated with you but unrelated to the browser, the charges will be dropped. The bans will still be there, and where they are gone, people will informally stick to them. People will not feel like they can put your company on their resume. Any casual mention of you on the social internet will inspire at least a half-dozen hate comments, and FOSS projects will be attacked for ever having mentioned you positively.
If you aren't a paragon, you sell out after the NYT story.
The reason there are monopolies is because they are enforced.
Really, I just can’t understand it.
Google has Android & ChromeOS to directly try to do that but Chrome makes it so the average user using e.g. Windows still ends up in a Google world most of the time.
To me this sounds like the point where people start looking at and developing alternatives to the browser/web.
I know some actual luddite-tier AI haters that believe it's ontologically evil, and another majoring in Data Science that went to the most recent career fair and told a recruiter "AI will replace you" (I uh don't think he's getting that internship)
And of course many, many, others that fall between the two extremes.
The one thing we can all agree on, is it makes homework a hell of a lot easier :) (well, except the luddite-types, they refuse to use it in any capacity)
Watching LTT all day? Playing on their iPhones constantly? Buying wireless earbuds?
I keep hearing stories about how homework is now useless because every student just gets ChatGPT to do it for them, and from personal experience, I'm inclined to believe them.
I don't believe every student uses a calculator to solve their math homework, so what makes ChatGPT unique here? For certain subjects the ability to cheat has been trivial for a long time, yet there was no crisis.
What kind of math homework has been trivial to solve with a calculator? I guess you're referring to elementary school arithmetic?
When I was in high school a classmate did their chemistry homework by buying the teachers edition of the textbook, which had the answer key. The whole class knew this trick existed, but most of us slogged through the work manually. I knew another group who divided up the homework problems and then combined. Students have always known how to cheat on homework, but enough students actually do it anyway.
What makes ChatGPT unique here?
Using AI to cheat at academics and then hating on people who use AI to cheat on media creation is absolutely hypocritical. Its qualifying hypocritical stupidity like this results in shoving a single vendor's LLM into the browser.
If that's still too complicated then just call it complexity - https://en.wikipedia.org/wiki/Cognitive_complexity
I personally use LLMs for coding assistance, and some home automation stuff, but I do not think this particular API is good for the web.
https://github.com/runvnc/tersenet
If you glance at that then you may see that I am for the idea of leaner alternatives to the current web platform.
But in the context of the existing web API which has just about everything and the whole kitchen sink in it (hundreds of sub-APIs), I do not think it will really help anyone at this point just just stop adding features, especially major ones.
The web is basically an overlay operating system and has been for many years.
Not OP but I think you are misunderstanding the interaction as a whole here. The Chromium team made a proposal, then the Chromium team asked the Firefox team for a position on the proposal. Whether or not the Firefox team or anyone on the Firefox team has any goals around AI or whatever, this response was simply "We do not like this proposal for these reasons..."
How to fix those issues really isn't the Firefox team's job and also wasn't part of the question asked by the Chromium team.
There are a lot of people reading his position. One or two additional clarifying sentences to spell it out for people skimming is not such an unreasonable ask.
I do think it is a bit unwarranted, actually. This isn't a press release, it's a technical discussion somewhat deep into a technical process that's open for archival purposes. His audience is not people skimming through, it's the Chromium team and other members of the standards body.
You're sort of overhearing a conversation and injecting yourself into it.
And this is not really a technical issue. It's a worldview issue no matter how much you or others try to pretend it's a technical problem or that I am violating etiquette or something.
I'm actually so curious what you think is going on here
It’s them articulating clear and logical reasons why the proposed API, in its current state, is bad for web interoperability.
fetch("https://api.openai.com/v1/chat/completions", { ... });Give it X months (or years??) and people will realize this is actually a privacy/data autonomy issue.
It's just dominated right now by the anti-AI/anti-technology sentiment in the west. That will gradually go away as more people use AI and robotics and realize how wrong they were about it.
Nothing in this proposal claims it has to be a local AI. That just happens to be the implementation by Chrome and Edge (for now at least, I'd imagine Google will eventually start moving this API towards hosted Gemini).
I will use WebLLM if I want something like this (with local AI guaranteed).
Maybe Mozilla can save itself by getting paid to serve Google's model as default rather than another providers. Would replace the revenue stream they lost.
That shipped sailed in 2008.
I don't know what the right answer is, but having used Niri/Wayland vs. GNOME vs. Windows vs. Mac... I will never go back to a non-tiling desktop and a none-kb driven workflow for desktop window management.
My experience with running LLMs locally is spinnnig up llama-server (possibly on a separate machine) and then configuring other applications to point to that OpenAI compatible web server instead of OpenAI or similar.
I don't want a web browser creating/running an LLM instance as that machine may not have the capability or capacity to run an LLM instance.
This is a way for web services to make your computer complete large amounts of compute at their behest. Tokens have value. There will be incentive for bad actors to use your local LLM for their own purposes, much like hostile crypto mining payloads.
This is an obvious target for prompt injection attacks and other malicious remote code execution. In many ways, model prompts ARE programs. The browser / local device would need to provide an LLM with the same sandbox guarantees as the rest of the browser. Can they be trusted to do that? Does anyone understand this well enough to do that with confidence?
I’m a big fan of local models, but I would be very cautious about letting random websites call the model I’m hosting on my local machine with open source software.
Pretty sure Chrome wouldn't ship if they weren't confident. And Firefox would object based on security grounds if they saw such an issue
Google is again doing Evil.
I am very annoyed that Google kind of de-facto controls the www (through chrome, let's be honest here).
We really need to change this. I don't have a good solution here, but it can not continue that way.
Chrome's introduction, albeit through smoother, lighter browser experience at the time, pushed other browsers to standardize to google.
In one way it's bad to have a homogenous approach to all things web based, but in another way it did make the internet a better experience overall.
Some libraries/scripts helped normalise things a little, but never enough. Yuck.
The same exact issues we had with IE.
Being a web developer was not fun; and the web was absolutely being held back. Chrome did a lot of things right: per-origin sandboxing, properly implementing web standards, V8, developer tools, and back then Chromium was super close to Chrome.
Do I think Chrome is a net-negative for the web over the past ~3-5 years? Yes, especially with manifest v3, “privacy sandbox”, and them basically forcing through web APIs because they have the dominant marketshare.
But early Chrome was a technologically impressive and user-friendly browser that really did make the web massively better.
I remember happily putting Firefox and Chrome mini-banners (what are they called? Those little rectangular images) on my website, for free, because I recommended it.
Advocacy (against chromium and its forks) is one way.
> Browsers and operating systems are increasingly expected to gain access to language models.
I think this is only true amongst “AI all the things” folks. Both tech and non-tech people around me are more focused on turning these features off. Some even avoid sensitive actions like banking from LLM infused browsers.
So I think Mozilla is right to object. This API is not in the interest of the user/agent.
Either way, if this does happen I definitely hope it gets put behind a brower permission.
He is more or less aligned with the current most common sentiment in the west which is largely publicly against AI.
But realistically it's just slow adaptation, network effects, etc.
To give an example, before the MLB rolled out the Automated Ball Strike system this year, last year maybe 65+% of the sentiment in discussions about it was negative or in some cases just neutral.
Now that it has rolled out, 95% of the sentiment online about ABS is positive. The main comment by far is, why didn't they do this before, and why don't they do it automatically on all pitches now.
There are certain cognitive and informational flow limitations in society that will cause this to be delayed, just like all major technological advancements.
But once it rolls out, the perspective you hear online will be about digital sovereignty/personal data autonomy, now we aren't required to send our data to an external provider for AI, why wasn't this available before. People will probably assume it was blocked because it reduced a major source of data for advertising or something.
And overall AI and robotics in the future will be seen as the greatest enabling factor for increased equality in society.
It's really just this underlying dislike of and disrespect for technology that much of the western public has. Which may turn out to be one of the reasons that we lose our de facto leadership position in the world.
But you haven't really made a technical argument because your objection is not really technical. It's a type of politics.
It's obviously extremely extremely useful to have a simple API for accessing an LLM. It needs permissions like most things and the ability to limit download sizes/specific or maybe block use of external services if desired.
But anyway people will just fall back to a slightly worse alternative like a wrapper around WebLLM (that wraps WebGPU).
It's probably not politically feasible for you to take a different stance anyway.
MLB's ABS does not use AI for its ball tracking. And it has specific payoffs particular to its context from four years of testing and wiel defined limits on use cases that don't necessarily generalize to issues surrounding AI and it's tradeoffs.
>> Do not engage … generating or distributing content that facilitates … Sexually explicit content Do not engage in misinformation, misrepresentation, or misleading activities. This includes … Facilitating misleading claims related to governmental or democratic processes
> This seems like a bad direction for an API on the web platform, and sets a worrying precedent for more APIs that have UA-specific rules around usage.
I will say this more strongly—I think it is completely insane, and a violation of free expression principles, for a browser API to have content restrictions.
Like, that sounds daft, but it's not really far from what they're doing here.
If a web developer wants to use a cloud model, with the associated legal requirements and business relationships of that model, we already have a way to do that: Use Fetch API on a CORS endpoint. There's no need to have the browser do cloud model brokering to a model you haven't tested with, run by a company you might not want to actually do business with.
[0]. https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/...
I think it was subsumed by later developments (javascript), but the issue with it AFAIR was just that it wasn't useable in all browsers, not that the tag per se was a bad idea (as much as scrolling text can be).
The situation with the model api seems different, more like the AMP spec.
However if this needs to be done, then it needs to be a opt-in per site permission at the very least, and there should be a way to verify the identity of which model is being prompted (which extends to even minor tweaks made to system prompts).
As a user I need to be sure that I can't be fingerprinted by navigating to a random site and them using this API without my permission.
As a dev I need to know what model my users are using, so I have the option to craft specific prompts per model.
I've been trying these models out for the last year, and it seems to me that we want them to work in a 5-10W "laptop" power envelope, but they really work best with a 50-500W GPU instead - i.e. they eat batteries. This means things work better in a "plugged in" gaming laptop/desktop rather than a typical web client. At least for now.
Oh no! Chrome is trying to enhance user agency again! Oh no! Chrome is trying to make the web better for end users!
Mozilla's concerns aren't totally bogus, I'm not going to try to laugh them out of the room. But their pearl clutching & belly-aching about "oh no what if not all implementations of ai prompts work exactly the same" feels fucking tired and weak sauce to me.
This post really doesn't deserve our attention, my my view. But I'd challenge the haters to at least try to connect their reflexive hate meaningfully to what the topic at hand actually is, to provide something worth considering in some way. But that I think asks too much, for what posts like this seek: merely to inflame the world.
Maybe you shouldn't reflexivly defend Chrome when they clearly abuse their market leading position to push their own AI.
We had WebSQL which defactor relied on a specific DB implementation, sqlite, and I suspect it also essentially couldn't be updated because people relied on the quirks of a specific version of sqlite.
But there's no suggestion or idea, no way to specify our way out of this one.
And the idea of providing too much guidance because one model has quirks? That seems so so very so-what. Oh no we over-prompted isn't zero impact. But it usually isn't that cataclysmic. I feel like this is such a 0.001% gripe, and to hold up all agency on the web because of this is unbecoming. Is ridiculous.
I know browsers wanted to get rid of websql but generally I thought the consensus was websql was disliked generally by vendors. It wasn't that they wanted a different websql: they didn't want a websql at all, period. The quirks weren't the problem.
Again though, fucking help! Fine, there are problems. I personally think this is some absurd fucking ridiculous mountains out of mole hills and ya'll are being absurd over this. Absurd. But if this was a discussion where there were interesting future directions to look to, that we could pursue and try to follow up on? Ok! Fine! Have your pound of flesh maybe or maybe it really does pay out! But it is some conservative Fear Uncertainty and Doubt soul rotting evil to obstruct & deny while making qualifications that are utterly unobtainable.
Meanwhile the rest of the software world is going to keep moving. The web is just going to be colossal negatively impacted by this impossible "it must be perfect" impasse created for no reason with no expectations of resolvability, in spite of the base premise of giving users access to their agents being an obvious direct and clear improvement over every other possibility by country miles.
Your fixated bias shows that your not willing to shuffle. Think out of the box for once.
No one is ruling out that Google is trying to enhance the internet, but at the same them rather it making positive and open it enables & restricts the next wave of generational internet.
How am I suppose to develop a uniformed application when I have to follow the rules of Google. Why should I have to, because I would be forced to.
It seems pretty basic to me that yes I should be able to have some agentic experiences working for me.
The Mozilla line here is that this is bad because different people might have different agents and that is intolerable, is a risk.
It's hiding in a cave to avoid seeing your own shadow idiotic.
If you are 99% against, that's at least some ability to judge reality. To have some ability to investigate & think. But you should be able to talk at least like you have some moorings, some connection with both sides of the discussion, imo, or you just aren't being serious.
It is clear this can be done without being part of the standard as is shown by the fact that it is already done. So it has no place in the standard.
This doesn't make any sense. And it's far less ideal than using already on device models, that are better tailored to the device's hardware, and that may be already resident.
Good things should be made broadly available. We didn't need jquery before it came along, we could just do the things. But jQuery set a standard. And in turn much of what it did got sent into improvements to query selector. Your model of standardize only the minimum sounds like suicide for the web and I think it's dreadful, and I'm glad such dour sad views have no standing.
Stop trying to make browser llms happen, they're not going to happen.
However, WebLLM (a library, not actual Web API) https://github.com/mlc-ai/web-llm is more capable and will already work using WebGPU.
Shouldn't be there a basic process for allowing such an API as a alpha people can play around with and then there will be adjustments?
No one will start using this in production if they don't have a very good and specific use case. I mean you don't just run 2gb ML models in your browser today on a massive scale.
There was such a process! They shipped as first Dev Trial around 2025-04, then Origin Trial in 2025-05. Since then a number of people tried it and gave lots of feedback, leading to model quality improvements, language support expansion, API additions like structured responses and tool use, etc. You can find a lot of feedback and case studies if you search around.
But most importantly this would enable us to finally write JavaScript like this:
const a = prompt("how much is 31c in Fahrenheit")
The future looks bright!
const cToF = c => c * 9/5 + 32; const a = cToF(31);
But if no browser other than Chrome supports this, and only Google's (proprietary) model (edit: plus Microsoft's Phi-4 mini in Edge), it should be clear it's Google abusing its position. There is nothing worth standardizing.
And we have seen that too many times -- FLoC/Privacy Sandbox/Topics API, Web Environment Integrity just to name a few. Google has been relentless in using its dominant position to push terrible ideas that harm both users and other browser vendors but help only Google's business.
Surprised this did not really come up in previous discussion in https://news.ycombinator.com/item?id=47917026
PS: looks like Google's fanboys have arrived. Someone better finds good counterarguments, especially technical ones, instead of just downvoting.
I am sympathetic to all of Mozilla's concerns here, even though on balance I believe Chromium's decision to ship was the right one.
---
On interoperability, I agree that this is a tough case. But I am more optimistic than Mozilla that developers will use this API in a way that can work across different models.
First, they will be somewhat forced to, because Chrome will change the model over time. (It already changed from Gemini Nano 2 to 3, and I suspect it'll change to 4 soon if it hasn't already.) Edge is already shipping a Phi-based version. A small number of users are using other models via extensions like https://aibrow.ai/. And it's very possible Safari might join the party, exposing the Apple Foundation Models that ship with iOS via this API. (When the Foundation Models API came out, we were struck by how similar it was to the prompt API designs that preceded it, and were hopeful that Apple was going to do a surprise announcement of shipping the prompt API. It hasn't happened yet, but I still think it might soon.)
Second, we designed the API to steer developers in that direction as much as possible, e.g. encouraging the use of structured output constraints. There are also lots of clear error paths, that almost force developers to use this as a progressive enhancement. (E.g., the existence of low-memory/disk space devices.) So it's very unlikely we'll see developers build sites that are gated on this API existing. It'll mostly be used to sprinkle some AI magic, or let users do cool things without entering some cloud API keys.
I made similar arguments for the writing assistance APIs at [1]. As I said there, the prompt AI is trickier than the writing assistance APIs. But I believe it's a difference of degree, not kind. The web has many nondeterministic APIs that access some underlying part of the system, from geolocation to speech recognition/synthesis, all the way up to these AI-based ones. The question is where you draw the line. Mozilla seems to be giving some signals (not yet definite) that translation is on the OK side of the line, but summarization/writing/rewriting/prompting is not. That's a very reasonable position for them to take on behalf of their users. I imagine the Chromium project is hoping that over time, in-the-wild experience with these APIs shows that the benefits outweigh the risks and costs, and so Mozilla (and Apple) follow in shipping them as well. That's definitely happened in other cases, e.g., Mozilla recently indicating interest [2] in implementing WebBluetooth, WebHID, WebNFC, WebSerial, and WebUSB after years of taking a wait-and-see attitude.
You can learn more about my general thoughts on this question of shipping APIs first, and how the Chromium project takes on first-mover risks, at [3], which I wrote during my time on the Chrome team.
---
On the prohibited use policy, I agree that this is just absurd on Chrome's part. This is not how web APIs should work. It smacks of lawyers trying to throw something out there to cover themselves, or of corporate policy being set at the top level for "all AI uses" and then applied even for web APIs where that makes less sense.
The only saving grace is that I suspect it won't actually trigger. Because, as Mozilla points out, it's quite impractical to enforce. But it's still wrong.
I hope Chrome changes this, although I'm not holding my breath.
I did find it interesting that Gemma seems to have a similar terms of use [4]. (Open-weights, not open-source!) As do the Apple Foundation Models in iOS [5]. So unfortunately if the Chrome team were to push for a no-TOS API, they might be forging new ground, which is always difficult in a large company.
---
On the issue of insubstantial developer signals, I think this is just a failure of the current Chrome team in terms of collecting and collating signals. If one pokes around and knows where to look in various threads, you can find a lot more positive signals than the outdated ones in [6]. I wouldn't have let that Intent to Ship get out the door without properly updating that section of the explainer, for sure. (But hey, not my job anymore!!)
[1]: https://github.com/mozilla/standards-positions/issues/1067#i... [2]: https://github.com/whatwg/sg/pull/264 [3]: https://www.chromium.org/blink/guidelines/web-platform-chang... [4]: https://ai.google.dev/gemma/terms [5]: https://developer.apple.com/apple-intelligence/acceptable-us... [6]: https://github.com/webmachinelearning/prompt-api/blob/main/R...
On interoperability, time will tell I guess. I've only been working on Firefox for a few months, but general interop issues are way worse than I realised when we worked together at Chrome. Firefox frequently gets bug reports for not behaving like Chrome, even when Firefox is complying with the spec, and Chrome is not. We end up having to just behave like Chrome.
On developer signals… I'm sure there's better evidence of positive sentiment than Chrome provided, but there's a lot of negative sentiment too. I think it would be fair to call the developer signal "mixed", or maybe even "polarised".
What's going to happen is that people build stuff with the current iteration and a few years later a model update will work entirely differently and break the existing implementations. I understand that every once in a while OpenAI also shuts off older models through API but that's a central process.
What if I have Firefox 150 users that haven't updated yet and Firefox 155 users that have different models, while Chrome 160 and Chrome 170 users also exist and have different models. Is it expected that I build entirely different implementations for every browser version out there? Don't the work groups try to prevent exactly that within HTML & CSS through feature gating?
Sucks to be corresponding via The Second Worst Website In The World (TM), but here we are. Hope all's well on your end.
A minor correction from Edge's perspective: we've participated in OT using Phi models, but have not shipped to Stable, and are unlikely to given the current shape of things. Developers have not given us feedback that they're relaxed about compatibility, but I would obviously welcome that sort of data in case anyone has it to hand.
Best,
Alex
I think this is an oddly optimistic outlook from someone who until recently worked at Google. A company that has shipped, and probably still ships, lots of sites and versions of sites gated behind "does your user agent say it is Chrome".
The models themselves would be standardized and the weights and everything should be identical between browsers. They’d be standard and ‘web-safe’ like CSS colors or fonts. Probably would help to give them really boring/unbranded names too. These would work identically across browsers and web developers can rely on them existing on modern setups.
If you want more models, you could install them as a user or your browser could ship them or the web developers could bundle them through a CDN (and another standard for shared big files across domains would probably be needed)
Not to mention many other UX questions the come with this, most importantly, how unusable these local models are on regular 3-year old laptops that are constrained in RAM, GPU/CPU capability and likely disk space despite what enthusiasts say here. (They have a Macbook Pro with 32+GB of RAM, reports it works great with xyz model -- fine -- but somehow thinks it works for everyone and local models are the future.)
The model is pretty slow on my M4 Pro mac.
The API allows the browser to use a cloud service instead, but then privacy is lower. So, more privacy for the rich.
...what's the exact problem here? Believe it or not, most non-tech-savvy users use the search engine just fine.
[0] https://www.reuters.com/technology/google-paid-26-bln-be-def...