W3C

– DRAFT –
Giving the user control over where AI models run in the browser

27 October 2026

Attendees

Present
Dave_Raggett, Kenji_Baheux, matatk
Regrets
-
Chair
Ehsan Toreini, Matthew Atkinson, Muadh Al Kalbani
Scribe
matatk

Meeting minutes

<toreini> https://docs.google.com/presentation/d/17wsUYy6ahb3mDhLb61wgKdCXWxnQmFJGye75vjw-Ono/edit?slide=id.h21dc2530e712e59a_0_0#slide=id.h21dc2530e712e59a_0_0

^ slides link

toreini: Lots of features use AI; it's often ambiguous where the computation gets done.

toreini: We must consider the user; what if the user demands local-only?

toreini: Different specs have different approaches to this.

toreini: Lots of proposals go to TAG; a common question is where is the trust boundary? Who is the attacker? Different threat model for local/cloud.

toreini: Also depends on the sort of device the user is using. Should it differ depending on whether there is a secure enclave?

toreini: Placement of model - is it for one task only, or shared across multiple tasks, with multiple threat models?

toreini: TAG doens't have consensus on the whole thing yet.

toreini: What about where the model is run though? There are 5 categories we discussed [as per slide]

toreini: A number of APIs have been reviewed recently. They are each tackling this issue, can we get some sort of agreement, so at the API level we can have some shared visioin?

toreini: 3 main frictions: OS and UA level settings are isolated.

toreini: Priority of constituencies - developers can conflict with users' needs. A boolean to indicate where the model runs may not be granular enough.

toreini: No standard mechanism means the outcome is unclear.

toreini: Our team is proposing an approach that seeks to provide a common, privacy-preserving approach.

toreini: Considers user needs, and device capabilities.

toreini: There is an enumeration of 5 possible compute locations, as suggested by TAG [per slide].

toreini: User and developer needs are considered to find a compute location that satisfies both if possible.

toreini: UA mediates trust and is mindful of priority of constitutencies (be on the side of the user)

toreini: One concern that has come up is we don't want to repeat 'do not track' - we agree

toreini: We feel this is different - DNT is a voluntary advisory signal, broadcast from the UA to other parties.

toreini: ...this is something that the UA is mediating itself.

toreini: ...and there's no connection with the network if the user doesn't want it.

toreini: We looked at risks, fingerprinting, mittigation, fallbacks.

toreini: E.g. timing and side-channel attacks. (and mitigations)

toreini: We hope to encourage interest from UAs. We welcome your input. We have 3 topics we'd like to discuss...

toreini: (want to hear all opinions!)

toreini: 1. Does the user need this?

toreini: 2. Shape of the 'API' - i.e. the enum to be shared across other standards

toreini: 3. Who wants to participate?

<Zakim> _draggett, you wanted to comment on persona zones and exceptions

_draggett: I was involved in a EU project called webinos - a trusted personal agent in the cloud. Concept is 'is it within your trust zoem or is it outside?'

_draggett: Exceptions will be needed. Your trusted agent may need to talk to another. User preferences could get complicated, and need to be easy to use.

toreini: You're asking about orchestration of agents?

_draggett: Yes, agent may be doing complex things for you - some may be faster locally and some may be faster in the cloud.

toreini: This comes back to the 3 sources of info on the slide. The developer will have a preference, as the user, and the device will have capabilities too.

<_draggett> user preferences need to be easy for everyone to understand and set, that's hard

<_draggett> concept of a personal zone with trusted devices and services, some of which may be remote.

Kenji_Baheux: Not sure of the scope of the proposal. My personal PoV from on-device APIs, the whole point wasn't that it's on device, but that it's low-friction access to AI capabilities; on-device happens to provide this, and provides privacy.

Kenji_Baheux: ...but it can't run every model.

Kenji_Baheux: Could be cheap to run some models on the server site - and some are private compute, that attest privacy.

Kenji_Baheux: Would be interesting to express that you care about your data being private, as opposed to 'I am willing to trust this provider'

Kenji_Baheux: The care is more about the capability (e.g. privacy) but not about where it runs.

toreini: This fits. It's a bit ambiguous to the user. When I create prototypes, I know it's running locally. For an end user, it's a bit more ambiguous. Say they want to run something from their watch, and offload the compute to their phone. We need to be able to account for this; that's what this proposal is trying to solve.

toreini: These choices, privacy, power, cost, are opaque to the user at the moment.

Kenji_Baheux: I've mostly been looking at it from the devs' point of view. There may be regulations that affect things. E.g. it may be private on- or off- device but regulation may require on-device only. Everyone wants privacy.

Kenji_Baheux: Maybe we need to split the user and developer's PoV

toreini: I like this idea; aligns with yesterday discusion with WebML, regaring performance policy.

toreini: Devleoper and user can specify preferences and UA chooses.

Kenji_Baheux: I think part of the challenge with having a way for uesr to express their preference: you can provide privacy guarnatee for AI inference, but sites can do whatever they want with the input or output of that computation.

AlexDawson: Concern about sustainability - local AI could be better for privacy and security, but shifts costs of computation and power on to end users.

AlexDawson: Whole-life impacts need to be considered, rather than shifting the burden of responsibility.

toreini: My understanding is that what you say is already happening - downloading models that could be large, to the UA.

AlexDawson: A well-optimized model at the server side could potentially have fewer impacts than an unoptimized model at the local device. The devices may not be optimized to run them. That may not always be the case, but there's a large surge in pepole having lower-powered devices, and people may not want to have large models absorbing what little data they have available on their devices.

AlexDawson: An off switch may need to be baked in.

mklimenko: 2 things I'd like to bring up...

mklimenko: 1: when we talk about local devices, it's not like you have 'a cloud' or 'a local device'. On a SoC you have CPU, GPU, NPU, with differing capabilities.

mklimenko: ...there may be a need to validate that a model runs on a device correctly. We are not dealing with performance, but conformance.

mklimenko: ...we may be running on devices from multiple years ago, which may have hardware bugs.

mklimenko: 2: distinction in the proposed/example API: tries to distinguish between personal and remote, and maps well enough for simpler AI like speech-to-text, text-to-speech, computer vision.

mklimenko: ...There's a surge in use of agents and orchestration. We have a harness, and multiple other agents.

mklimenko: ...The harness may run locally, but may need to refer to other more beefy agents that are remote.

toreini: I would separate your discussion into 2 categories. One is whether the abstraction we propose captures the different categories of device. For the second one, we are trying to address the current API surface challengs that we are facing. E.g. Prompt API downloads the model inside the UA. I totally can see the scenario you propose can happen in the near future.

toreini: Should we solve that now, or leave the abstraction open, to be extended as needed later?

toreini: It's a fast-moving area. I don't have an answer to the second one.

mklimenko: I don't have an answer right now, but we probably don't want to limit ourselves with too rigid an API, as we could get devs to use it, but then have to break it.

Kenji_Baheux: Regarding Prompt API. Right now it downloads the model and runs locally.

Kenji_Baheux: We had a vision of having a component, and running it server-side if people are OK with it.

Kenji_Baheux: We removed this though.

Kenji_Baheux: Web Speech API is older and has been server-side for a long time. So we added the boolean to process locally. You could also imagine the reverse: 'I don't really mind where it's happening' or 'I do care about privacy, and it needs to be attested, rather than just being taken on trust'

toreini: I think that boolean property was a result of the TAG discussion. We have a lot of discussions around 'what happens if it's local? ...' so this proposal is trying to solve this more general.

toreini: The example you give is developers set the boolean and doesn't consider the user's opinion.

Kenji_Baheux: Sometimes it is possible to get an indication of why a device can't run a model - the API doesn't get to know why. A user settings page in the UA could be used to ask the UA to disallow use, but not say reasons.

toreini: Some UAs clearly ask users, give them some control. Others don't show the user anything. We'd like to be consistent with each other despite the differences we have. I like what you're saying, but maybe we too can have a more inclusive approach and include your PoV.

reillyg: To mirror Kenji_Baheux, toreini and I started talking about this area because we were dealing with the question of whether to pull cloud execution out of the specs. It was left in as an option but confused TAG, as it completely changes the privacy and security charactersitics of the specs.

reillyg: I've been thinking about how we manage all of these things: privacy, security, data sovereignty, performance, economic considerations.

reillyg: How do we get enough info from the user and dev to enable the UA to make a reasonable decision?

reillyg: This proposal makes sense to me. Both the uesr and the dev have requirements and prefernces; both need to be taken into consideration.

reillyg: The place where this proposal will struggle is that it'll be difficult to convince browser vendors.

reillyg: ...to put such a complex choice in front of users.

Kenji_Baheux: Maybe it would be easier to get started in enterprise. Having a policy that could be expressed across an organization.

reillyg: Yes, for legal and other requirements, enterprize policy could be helpful.

reillyg: We know both that some user's don't want their data sent anywehre else, and others don't want the browser downloading large things.

toreini: The key here is that cloud and local have different threat models.

toreini: And APIs are trying to be designed to cover both cases.

toreini: Allowing the UA to manage it may be helpful.

AlexDawson: Most browsers have site-based permissions or browser permissions. Potentially that may be one way of going about it. We treat hardware in isolation that way. For LLMs I think this is a good way of going about it.

AlexDawson: For conformance purposes, info could leak out; in some environments people aren't allowed to allow info to leak out.

AlexDawson: Being able to provide a sandboxed LLM may be helpful.

toreini: Could you explain it a different way?

AlexDawson: E.g. if the LLM was sandboxed in the browser in much the same way as tabs, that could help.

reillyg: That's already true. There's often an assumption that the sites get access to additional context about the user, but it's not the case with any of the APIs we are specifying.

Kenji_Baheux: There's no personalization.

toreini: There's no training happening locally.

reillyg: Even if there were, it would be site-specific and only observable by that developer.

toreini: Would that solve your concern AlexDawson?

AlexDawson: If we're concerned with how we provide it to users, using site-based permissions is a well-defined way of doing this. Recognized by users that they can allocate permission for access to hardware.

toreini: Agree with the core of what you're suggesting to give the user agency.

toreini: It can be a double-edged sword, we have to be careful about the friction we're creating.

nordzilla: Wanted to second some of the things I've heard. I love the idea of giving the user choice, I'm very passionate about that. Having these discussions about the right configurations to present to users is important. I liked what AlexDawson brought up about model downloads and size needing to be part of this.

nordzilla: I don't personally thing the answer to agentic browsing is to throw LLMs at everything; I think we can have smaller, targeted models. Some of the smaller translation models are e.g. 40M. They are not all massive and require massive GPU to run - but even at that size, some users on a mobile network may not want to download that right now.

nordzilla: There's a lot of nuance here. Want to second what reillyg said, that browser vendors often struggle to present easy intuitive choices to not so easy to understand problems.

nordzilla: Looking at this proposal, a majority of non-technical people wouldn't know what to do with remote attested vs remote secure.

nordzilla: I love that we're talking about it and working towards consensus.

<AlexDawson> Even if the LLM is sandboxed like a browser tab, and websites receive no additional user context, there is still an indirect prompt-injection risk. Malicious content in a third-party advert or compromised script could influence the LLM to perform unintended actions within the page, provided the LLM has the necessary capabilities. Sandboxing limits

<AlexDawson> what it can access, but does not necessarily prevent it from being manipulated into misusing the permissions it does have. How are the browser's permission boundaries and action authorisation enforced independently of the LLM?

mklimenko: re asking for user's permissino to run something on their machine... it makes sense because even small models e.g. computer vision, could be power-hungry.

mklimenko: IMO we should allow users to disallow local execution. We should expect the users will click the button to restrict it, so all applications should have a server fallback.

toreini: For many of the APIs there is some sort of friction but I've not seen clear prompt-based permissions models being used.

toreini: For Prompt API it needs specific user activiation.

toreini: We can discuss the level of friction.

Kenji_Baheux: this is something we're iterating on

mklimenko: The agreement to run the model locally - is it click on a random place on a webpage, or is an explicit allow/disallow.

reillyg: Currently just a click to unlock the downlaod but we're considering a number of updates to make the consesnt part clearer.

matatk: As brought up in the discussion, the user's decision may depend on certain things like being on mobile, and others, so will change over time.

Kenji_Baheux: could be also battery level

toreini: In the last 2min: how can we move forward?

toreini: We have an explaienr for CLAPI. We have an issue on Translation API.

toreini: In general what's the next step?

_draggett: WebML WG is rechartering soon.

toreini: Very good point

<toreini> https://github.com/SamsungInternet/Explainers/blob/main/ComputeLocation/compute-location.md

reillyg: I suspect this component would be integrated into one of the existing spes - we have a number of common pieces shared between multiple APIs.

reillyg: Might be useful to explicitly make it clear that server-side compute is in scope, and laying out as a separate deliverable an exploration as you've done here of the design challenges, as every API using it, it may be the same but the privacy and security consideratoins may be separate.

Minutes manually created (not a transcript), formatted by scribe.perl version 250 (Wed Oct 21 13:34:09 2026 UTC).

Diagnostics

Maybe present: _draggett, AlexDawson, mklimenko, nordzilla, reillyg, toreini

All speakers: _draggett, AlexDawson, Kenji_Baheux, matatk, mklimenko, nordzilla, reillyg, toreini

Active on IRC: _draggett, AlexDawson, breakout-bot, Kenji_Baheux, matatk, mklimenko, nordzilla, reillyg, toreini