---
title: "WebMCP and Chrome's Prompt API: Can You Build a Free Site Chatbot?"
date: "2026-10-25"
video_id: "7699151609594465550"
tiktok_url: "https://www.tiktok.com/@agentic.conversations/video/7699151609594465550"
creator: "@agentic.conversations"
category: "AI"
tags: ["webmcp", "prompt api", "chrome built-in ai", "gemini nano", "mcp"]
excerpt: "Chrome's Prompt API can take WebMCP tools, but the tools option is experimental and WebMCP is an origin trial from Chrome 149. Here is what works today."
---
WebMCP is a draft web standard that lets a page register tools, such as `search_products` or `add_to_cart`, that an AI agent can call. A TikTok from @agentic.conversations, cut from an interview with Google's Dominic Farolino, says sites can feed those tools into Chrome's Prompt API to get a "free chatbot" that acts on the page. The syntax is real, but the `tools` option is marked experimental and WebMCP is an origin trial from Chrome 149, so this does not run on stable Chrome today.

## What is WebMCP?

WebMCP is published by the Web Machine Learning Community Group as a "Draft Community Group Report, 20 October 2026." That is an incubation venue, not the W3C Recommendation track. Chrome's documentation describes it as "A standard way for pages to register tools with agents."

In the current draft, each `Document` has its own `ModelContext`, and pages register tools with `document.modelContext.registerTool()` and list them with `document.modelContext.getTools()`. Much material from earlier in 2026 uses `navigator.modelContext`, so start from the current draft if you are building against it.

## Can the Prompt API use WebMCP tools?

Yes, in experimental contexts. The video shows the line `LanguageModel.create({ tools })`, and that is genuine syntax. MDN documents `tools` as "An array of objects representing tools available to the AI." Each tool carries a `name`, a `description`, an `inputSchema` (a JSON Schema for its parameters) and an `execute` callback that returns a promise resolving to a string.

The Prompt API Draft Community Group Report of 16 October 2026 defines the option this way:

```
dictionary LanguageModelCreateCoreOptions {
  // Tools that the language model can use.
  // **EXPERIMENTAL**: Only available in experimental contexts.
  sequence<LanguageModelToolDeclaration> tools = [];
};
```

Chrome's own Prompt API documentation covers `monitor`, `signal`, `samplingMode`, `initialPrompts`, `expectedInputs` and `expectedOutputs`, and does not list `tools` at all. MDN notes the feature "is not Baseline because it does not work in some of the most widely-used browsers." The base Prompt API is stable in Chrome 148 on the web and Chrome 138 in extensions, but the `tools` option on it is not.

## Is WebMCP available in Chrome?

Only through an origin trial. Chrome's WebMCP page tells developers to "Join the 'WebMCP origin trial' from Chrome 149" and warns that "WebMCP is under active discussion and subject to change in the future." For local testing it points to the flag `chrome://flags/#enable-webmcp-testing`. The video describes the setup in the present tense as something "people are using," and leaves this out.

## Is an on-device chatbot really free?

Free means no API key and no per-token bill for the site owner, because the Prompt API runs Chrome's on-device model. The cost moves to the visitor's machine. Chrome's getting-started page lists the requirements:

- At least 22 GB of free space on the volume with the Chrome profile. If free space drops below 10 GB after download, the model is removed.
- More than 4 GB of VRAM, or 16 GB of RAM and 4 CPU cores.
- An unmetered connection for the first model download. Later use works offline.

Platform support is the bigger limit for a shop. The model APIs run on Windows 10 or 11, macOS 13 or later, Linux, and Chromebook Plus devices. Chrome's page states that "Chrome for Android, iOS, and non-Chromebook Plus ChromeOS devices are not yet supported." A store that relies on this as its only assistant leaves out its mobile visitors and visitors on lower-spec desktops.

## How do in-page agents and the browser agent work together?

The first half of the clip is about coordination between the browser's own agent and agents embedded in page iframes. Its diagram, an "in-page agent" inside an iframe connected to a separate "browser agent," matches what the spec models.

Because each framed document has its own `ModelContext`, an iframe registers tools in its own context. A tool's `exposedTo` member is "An array of origins that control which documents this tool is exposed to, in the current document's tree." Execution across separate top-level browsing contexts is not allowed, and an origin mismatch rejects with a `NotFoundError`.

The caption "Sub-agents" frames this as Farolino's idea, but the phrase "It's almost like a sub-agent" comes from the interviewer, and Farolino answers "Yeah, exactly." "Sub-agent" is not a term the WebMCP spec uses. The clip uses drawn illustrations and a reserved example domain, `trailshop.example`, and never shows a working demo.

## Who is building WebMCP?

The video's description credits "Dominic Farolino's team at Google." Farolino is billed on the AGNTCon + MCPCon Europe 2026 schedule as "Editor of the WebMCP Specification & Software Engineer, Google." The draft lists four editors, though: Brandon Walderman (Microsoft), Khushal Sagar (Google), Dominic Farolino (Google) and Samuel Dallstream (Microsoft). The repository acknowledges more contributors from both companies and notes that the draft "has evolved significantly, primarily driven by Dominic Farolino."

The interview was recorded at AGNTCon + MCPCon Europe in Amsterdam on 17 and 18 September 2026, where Farolino gave the talk "Three Doors to One Tool: MCP vs WebMCP vs CLI." The clip went up 37 days later.

## Bottom line

Feeding a page's WebMCP tools into `LanguageModel.create({ tools })` is real and spec-defined. It is experimental, WebMCP itself requires an origin trial from Chrome 149 or a testing flag, and the on-device model excludes Android, iOS and lower-spec machines. Treat it as something to prototype now, not something to ship as a site's only chatbot.

## Sources

- [The Prompt API (Chrome for Developers)](https://developer.chrome.com/docs/ai/prompt-api): documented `create()` options and stable release versions.
- [LanguageModel: create() (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/LanguageModel/create_static): shape of the `tools` option.
- [Prompt API Draft Community Group Report](https://webmachinelearning.github.io/prompt-api/): the experimental annotation on `tools`.
- [WebMCP Draft Community Group Report](https://webmachinelearning.github.io/webmcp/): editors, `ModelContext` and `exposedTo`.
- [webmachinelearning/webmcp on GitHub](https://github.com/webmachinelearning/webmcp): contributors and API surface names.
- [WebMCP (Chrome for Developers)](https://developer.chrome.com/docs/ai/webmcp): origin trial from Chrome 149 and the testing flag.
- [Get started with built-in AI](https://developer.chrome.com/docs/ai/get-started): hardware and platform requirements.
- [AGNTCon + MCPCon Europe 2026 schedule](https://agntconmcpconeu26.sched.com/): event dates and Farolino's session.


## Video description and verification notes

**A 31.445011 s MP4 (QuickTime/MOV container, `mov,mp4,m4a,3gp,3g2,mj2`), 720x1280 portrait, SDR, HEVC Main profile level 120 in an `hvc1` tag at `yuv420p` and a constant 25/1 fps across 786 video frames at 177,724 bps, with HE-AACv2 stereo audio at 44,100 Hz and 64,366 bps across 681 audio frames, 247,653 bps overall and 973,435 bytes on disk, which matches `metadata.json`'s `filesize` field byte for byte under format id `bytevc1_720p_247646-1`; the separately extracted `audio.mp3` runs 31.503673 s at 144,105 bps and 567,481 bytes. Posted at epoch 1792944000, which is 2026-10-25 16:00:00 UTC, by handle @agentic.conversations (numeric id 7535882886172460046) under the nickname "Agentic Conversations", credited to "original sound - Agentic Conversations" by artist "Agentic Conversations", with a 478-character description. At capture time (the `metadata.json` mtime, 2026-10-26 18:41:44 local) the clip showed 376 views, 7 likes, 0 comments, 0 reposts and 5 saves. I read all 16 of the pre-extracted 2 s frames (001 through 016) plus four re-extracted 1 fps frames (020, 022, 023, 030) for 20 frames total, against a 130-word transcript in 16 segments. Frames 001 and 002 (0 s, 2 s) show a man against a black backdrop speaking into a handheld mic held by an off-camera interviewer, under a red-chip caption reading "Sub-agents"; his badge reads "AGNTCon + MCPCon Europe" across the header, then "DOMINIC FAROLINO", then "Google", then a QR code, then "SPEAKER", and the lanyard is printed "Runlayer" in repeat. Frame 003 (4 s) cuts to an illustrated browser mock titled "Trail Shop" with the URL bar `trailshop.example/runners`, a product called "Trail Runner 2" priced "$128", an "Add to cart" button and a right-hand panel labelled "browser agent", captioned "in the browser". Frame 004 (6 s) adds a red dashed box tagged `<iframe>` containing a second panel labelled "in-page agent", captioned "in-page agents". Frame 006 (10 s) puts "How can I help?" inside that iframe, draws a curve from it up to the browser agent panel and shows a faint `search()` chip below, captioned "and how they can". Frame 010 (18 s) is the load-bearing diagram: a card headed `trailshop.example` carries a black "WebMCP" badge and four tool chips reading `search_products`, `add_to_cart`, `apply_coupon` and `track_order`, and below it a "Chrome" card with a pink sparkle icon, the words "Prompt API" and the monospace line `LanguageModel.create({ tools })`. Frame 011 (20 s) shows the chips migrating into the Chrome card behind a green counter badge reading "2 tools", and the re-extracted 1 fps frame 022 (about 21 s) shows the same shot with the counter settled at "4 tools", a value the 2 s sampling never captured. Frames 013 and 014 (24 s, 26 s) return to the Trail Shop window with an "assistant" panel in which a blue user bubble reads "Add the Trail Runner 2, size 10, to my cart" and two chips read `search_products()` and `add_to_cart()`. No real browser, DevTools console, code editor, terminal, origin-trial token or live URL appears in any frame I read; every interface shot is a drawn illustration and `trailshop.example` is a reserved example domain, so the clip never shows the thing it describes actually running. The spoken argument has two parts: Chrome is working out how the browser's own agent and agents embedded in page iframes coordinate across tools, and separately people have wired a page's WebMCP tools into Chrome's Prompt API so the on-page chatbot can act rather than only answer. On the transcript-end check, the last segment runs 30.760 s to 32.280 s against a 31.445011 s audio stream, an overshoot of 0.835 s; because the segment starts well inside the audio and frame 016 at 30 s burns in the matching caption "Yeah exactly", this is a rounding artifact on the end timestamp and the words are genuine, with no segment wholly past the end and nothing fabricated.**

## The "sub-agent" framing the video leads with is the interviewer's line, not Farolino's

The red chip caption on frames 001 and 002 reads "Sub-agents", and the description closes its second sentence with "almost like a sub-agent". Both present the phrase as the speaker's characterization. The transcript at 29.520 s to 30.760 s says "It's almost like a sub-agent." and at 30.760 s "Yeah, exactly."

The 2 s frame set cannot resolve who speaks the first of those two lines, because frame 015 lands at 28 s and frame 016 at 30 s, with the cut in between. Re-extracting at 1 fps settles it: frame 030 of `tokdoc_frames_1s/` (about 29 s) shows a different person entirely, bearded, in profile, facing the stage lighting, wearing the same "Runlayer" lanyard, under the caption "It's almost like". That is the interviewer. Frame 016 of the 2 s set, at 30 s, returns to Farolino under the caption "Yeah exactly".

The substantive claim Farolino makes himself ends at 29.520 s with "it can actuate things on the site for the user". The sub-agent analogy is the interviewer's compression of that, and Farolino's contribution to it is a two-word agreement. The clip is titled and captioned around the analogy rather than the mechanism, and "sub-agent" is not a term the WebMCP specification uses. The [WebMCP Draft Community Group Report of 20 October 2026](https://webmachinelearning.github.io/webmcp/) models the relationship structurally instead: each `Document` object has an associated `ModelContext`, and a tool carries an `exposedTo` member described as "An array of origins that control which documents this tool is exposed to, in the current document's tree."

## Correction: the `tools` option is real spec syntax, and the spec labels it experimental

At 17.780 s the video says "So you can have a bunch of WebMCP tools on your site," and at 20.240 s "feed them into the Prompt API, and now you". Frame 010 at 18 s renders the mechanism as `LanguageModel.create({ tools })` under a "Prompt API" label. A viewer would reasonably take this as something they can write today in Chrome.

The syntax is genuine. [MDN's `LanguageModel.create()` reference](https://developer.mozilla.org/en-US/docs/Web/API/LanguageModel/create_static) documents `tools` alongside `expectedInputs`, `expectedOutputs`, `initialPrompts`, `monitor` and `signal`, and describes it as "An array of objects representing tools available to the AI", each carrying a `name` ("A string giving the tool a unique name the model uses to refer to it when issuing a tool call"), a `description`, an `inputSchema` ("A JSON Schema that describes the tool's input parameters"), and an `execute` callback that "must return a `Promise` that resolves with a `String` representing the tool's result". MDN also notes the feature "is not Baseline because it does not work in some of the most widely-used browsers."

The gating is the part the video leaves out. The [Prompt API Draft Community Group Report of 16 October 2026](https://webmachinelearning.github.io/prompt-api/) defines the option as:

```
dictionary LanguageModelCreateCoreOptions {
  // Tools that the language model can use.
  // **EXPERIMENTAL**: Only available in experimental contexts.
  sequence<LanguageModelToolDeclaration> tools = [];
};
```

and the declaration itself as `required DOMString name; required DOMString description; required object inputSchema;`. The comment "Only available in experimental contexts" is in the normative dictionary, not in a footnote. Independently, [Chrome's own Prompt API documentation](https://developer.chrome.com/docs/ai/prompt-api) walks through `LanguageModel.create()` with `monitor`, `signal`, `samplingMode`, `initialPrompts`, `expectedInputs` and `expectedOutputs`, and does not document a `tools` option at all. Two first-party surfaces, the spec and the Chrome docs, agree that this is not a stable-channel feature, and the video does not say so.

## Correction: WebMCP is an origin trial from Chrome 149, not a shipped browser feature

At 20.240 s the video describes feeding "a bunch of WebMCP tools on your site" into the Prompt API as a thing "people are using", phrased in the present tense. Frame 010 at 18 s stamps a black "WebMCP" badge on the site card as though it were an ordinary page capability.

[Chrome's WebMCP documentation](https://developer.chrome.com/docs/ai/webmcp) states the opposite twice. It instructs developers to "Join the 'WebMCP origin trial' from Chrome 149", which is the registration path for an unshipped API rather than a stable one, and it warns that "WebMCP is under active discussion and subject to change in the future". For local work it points at the flag `chrome://flags/#enable-webmcp-testing`. The page describes the discovery mechanism as "A standard way for pages to register tools with agents" without a stable-channel availability claim anywhere on it.

The standards status matches. The [WebMCP specification](https://webmachinelearning.github.io/webmcp/) is published as a "Draft Community Group Report, 20 October 2026" by the Web Machine Learning Community Group, which is an incubation venue rather than the W3C Recommendation track. Five days before this video was posted, the document was a community group draft.

I could not reach a first-party page stating the final milestone of the origin trial. Secondary write-ups put the window at Chrome 149 through 156; `developer.chrome.com/blog/webmcp-origin-trial` and `developer.chrome.com/docs/ai/webmcp-imperative` both returned HTTP 404, and the Chrome Origin Trials console view and the Chrome Platform Status search page both returned no usable content to this fetcher. The end milestone is therefore Unverified here. The Chrome 149 start is first-party and solid.

## Partial correction: "Dominic Farolino's team at Google" undersells a cross-vendor editor list

The description credits the coordination work to "Dominic Farolino's team at Google". The badge in frames 001 through 016 confirms the name spelling, "DOMINIC FAROLINO", and the employer line "Google", and the [AGNTCon + MCPCon Europe 2026 schedule](https://agntconmcpconeu26.sched.com/) bills him as "Editor of the WebMCP Specification & Software Engineer, Google". Both halves of the description's attribution are accurate as far as they go.

The specification's own editor block is wider than one Google team. [The WebMCP draft](https://webmachinelearning.github.io/webmcp/) names four editors: Brandon Walderman (Microsoft), Khushal Sagar (Google), Dominic Farolino (Google) and Samuel Dallstream (Microsoft). The [WebMCP repository](https://github.com/webmachinelearning/webmcp) acknowledges a longer contributor set including Leo Lee (Microsoft), Andrew Nolan (Microsoft), David Bokan (Google) and Hannah Van Opstal (Google), and records that "Since then, the specification draft has evolved significantly, primarily driven by Dominic Farolino." Half the named editors work at Microsoft. Describing the effort as a Google team's work is the kind of compression that makes a two-vendor incubation read like a single-vendor launch.

## Verified: the iframe picture in frames 004 and 006 matches what the spec actually models

At 4.500 s the video says "dealing with in the browser versus those in-page agents" and at 7.060 s "that pop up in iframes and help the user out." Frames 004 and 006 draw exactly that: a red dashed rectangle tagged `<iframe>` holding an "in-page agent" panel, with a curve connecting it to a separate "browser agent" panel outside the page.

The specification treats this as a first-class case rather than a metaphor. Each `Document` has its own associated `ModelContext`, so a framed document registers tools in its own context. The `exposedTo` member on a tool is "An array of origins that control which documents this tool is exposed to, in the current document's tree", which is precisely the parent-and-iframe relationship the diagram draws. The spec also fences the boundary the diagram implies: execution across separate top-level browsing contexts is not permitted, and "If targetOrigin is not same origin with expectedTargetOrigin, then queue a global task ... to reject promise with a `NotFoundError`." The current API surface for this in the spec text is `document.modelContext.registerTool()` and `document.modelContext.getTools()`, per both the draft and the repository README.

One dating note the frames do not show. Much written material from earlier in 2026 describes the surface as `navigator.modelContext`, and the 20 October 2026 draft uses `document.modelContext`. The video never names a surface on screen, so this is not an error in the clip, but anyone reproducing what the clip describes should start from the current draft rather than from a mid-2026 tutorial. I found no first-party page stating which Chrome milestone deprecated the older name, so I do not cite one.

## Partial correction: "free chatbot" means no per-token bill, and it excludes most of your mobile traffic

At 22.020 s the video says "kind of have this free chatbot on the site," and at 24.420 s "but it's actually useful now." Frame 012 at 22 s burns in "free chatbot" over a whiting-out Trail Shop window. The economic claim is the clip's most quotable line and its least qualified one.

The "free" is real in one dimension. The Prompt API runs Chrome's on-device foundation model, so there is no API key and no per-token invoice for the site operator. The cost moves onto the visitor's machine, and [Chrome's built-in AI getting-started page](https://developer.chrome.com/docs/ai/get-started) lists what that costs. The device needs "At least 22 GB of free space on the volume that contains your Chrome profile", and if free space drops below 10 GB after download the model is removed and redownloads later. It needs "Strictly more than 4 GB of VRAM" and "16 GB of RAM or more and 4 CPU cores or more". The initial model download needs "Unlimited data or an unmetered connection", though later use works offline.

The platform list is the sharper constraint for a retail site like the one in the diagram. The foundation model APIs run on Windows 10 or 11, macOS 13 or later, Linux, and ChromeOS platform 16389.0.0 or later on Chromebook Plus devices only. The same page states that "Chrome for Android, iOS, and non-Chromebook Plus ChromeOS devices are not yet supported." A shop that ships this as its only assistant has built a feature that a large share of its mobile visitors cannot load at all, and that under-spec desktop visitors cannot load either. The Prompt API reached stable on the web in Chrome 148 and in extensions in Chrome 138, so the base API is shipped even though the `tools` option on it is not.

## Key Takeaways

- **Verified:** The speaker is Dominic Farolino of Google, spelled as the video's description spells it, confirmed by the conference badge legible in frames 001 through 016 and by the AGNTCon + MCPCon Europe schedule, which lists him as "Editor of the WebMCP Specification & Software Engineer, Google".
- **Verified:** `LanguageModel.create({ tools })`, the exact line rendered on frame 010 at 18 s, is real specification syntax. MDN documents `tools` with `name`, `description`, `inputSchema` and `execute`.
- **Correction:** The video presents feeding WebMCP tools into the Prompt API at 17.780 s to 22.020 s as current practice. The Prompt API Draft Community Group Report of 16 October 2026 marks the `tools` dictionary member "**EXPERIMENTAL**: Only available in experimental contexts", and Chrome's own Prompt API documentation does not list a `tools` option among `create()`'s parameters.
- **Correction:** The video treats WebMCP as a present-tense site capability. Chrome's WebMCP documentation tells developers to "Join the 'WebMCP origin trial' from Chrome 149", warns that WebMCP "is under active discussion and subject to change in the future", and routes local testing through `chrome://flags/#enable-webmcp-testing`. The specification was a Draft Community Group Report dated 20 October 2026, five days before this clip was posted.
- **Correction:** The caption chip and the description credit the "sub-agent" framing to the interview subject. The 1 fps frame 030 at about 29 s shows a different person on camera saying it; Farolino's own contribution, on frame 016 at 30 s, is "Yeah exactly".
- **Partial correction:** The description says "Dominic Farolino's team at Google". The WebMCP draft names four editors, two at Google (Khushal Sagar, Dominic Farolino) and two at Microsoft (Brandon Walderman, Samuel Dallstream).
- **Partial correction:** "Free chatbot" at 22.020 s means no per-token billing for the site owner. Chrome's requirements put 22 GB of free disk, more than 4 GB of VRAM, 16 GB of RAM and 4 CPU cores on the visitor, and exclude Chrome for Android, iOS and non-Chromebook-Plus ChromeOS entirely.
- **Verified:** The iframe diagram in frames 004 and 006 matches the specification. Each `Document` has its own `ModelContext`, `exposedTo` governs "which documents this tool is exposed to, in the current document's tree", and cross-traversable execution is rejected with a `NotFoundError` on an origin mismatch.
- **Clarification:** No frame I read shows a running demo. There is no browser window that is not a drawing, no console, no terminal, no editor and no origin-trial token, and the only URL shown is the reserved example domain `trailshop.example`.
- **Context:** The 2 s frame sampling caught the tool-ingest counter mid-animation at "2 tools" on frame 011 at 20 s. Re-extraction at 1 fps shows it settling at "4 tools" around 21 s, matching the four chips named on frame 010: `search_products`, `add_to_cart`, `apply_coupon` and `track_order`.
- **Context:** The interview was recorded at AGNTCon + MCPCon Europe, held 17 and 18 September 2026 in Amsterdam, where Farolino spoke on "Three Doors to One Tool: MCP vs WebMCP vs CLI" on Friday 18 September at 09:29 CEST in the Auditorium. The clip went up on 2026-10-25, 37 days after the event, so the state of the APIs it describes had already moved by the time it was published.
- **Unverified:** The end milestone of the WebMCP origin trial, and the Chrome milestone that deprecated `navigator.modelContext` for `document.modelContext`. `developer.chrome.com/blog/webmcp-origin-trial` and `developer.chrome.com/docs/ai/webmcp-imperative` both returned HTTP 404, and neither the Chrome Origin Trials console view nor the Chrome Platform Status search returned usable content, so I cite no source for either.

## Resources

- [The Prompt API, Chrome for Developers](https://developer.chrome.com/docs/ai/prompt-api) establishes the documented `LanguageModel.create()` option set (`monitor`, `signal`, `samplingMode`, `initialPrompts`, `expectedInputs`, `expectedOutputs`) with no `tools` member, and the stable availability I cite: Chrome 148 on the web, Chrome 138 for extensions.
- [LanguageModel: create() static method, MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/API/LanguageModel/create_static) establishes the exact shape of the `tools` option, including the `name`, `description`, `inputSchema` and `execute` members and the requirement that `execute` resolve with a string.
- [Prompt API, Draft Community Group Report, Web Machine Learning Community Group, 16 October 2026](https://webmachinelearning.github.io/prompt-api/) establishes the `LanguageModelCreateCoreOptions` dictionary, the `LanguageModelToolDeclaration` definition, and the "**EXPERIMENTAL**: Only available in experimental contexts" annotation on `tools` that the correction turns on.
- [WebMCP, Draft Community Group Report, Web Machine Learning Community Group, 20 October 2026](https://webmachinelearning.github.io/webmcp/) establishes the four-editor list, the document's community-group draft status and date, the per-`Document` `ModelContext`, the `exposedTo` definition and the cross-origin `NotFoundError` behaviour.
- [webmachinelearning/webmcp repository, GitHub](https://github.com/webmachinelearning/webmcp) establishes the wider contributor list across Google and Microsoft, the note that the draft has been "primarily driven by Dominic Farolino", and the `document.modelContext.registerTool()` and `document.modelContext.getTools()` surface names.
- [WebMCP, Chrome for Developers](https://developer.chrome.com/docs/ai/webmcp) establishes the origin-trial status from Chrome 149, the `chrome://flags/#enable-webmcp-testing` local flag, and the first-party warning that WebMCP "is under active discussion and subject to change in the future".
- [Get started with built-in AI, Chrome for Developers](https://developer.chrome.com/docs/ai/get-started) establishes the 22 GB free-space, more-than-4 GB VRAM, 16 GB RAM and 4-core requirements, the unmetered-connection requirement for the model download, and the exclusion of Chrome for Android, iOS and non-Chromebook-Plus ChromeOS.
- [AGNTCon + MCPCon Europe 2026 schedule](https://agntconmcpconeu26.sched.com/) establishes the 17 and 18 September 2026 Amsterdam dates, Farolino's session title "Three Doors to One Tool: MCP vs WebMCP vs CLI" at 09:29 CEST on Friday 18 September, and his billing as "Editor of the WebMCP Specification & Software Engineer, Google".
