App -> Agent explicit integration/manifest?

[pmeenan]

As best as I can tell, most of WebMCP is around the plumbing of exposing in-page capabilities through an API to Agent(s) (either external, browser-supplied or in-page).

Is the page->agent triggering flow in-scope (or did I miss it)?

I "built" a CVE analysis tool with built in LLM for exploring CVE data (mostly because I had some questions I wanted to answer, I had tokens to burn and it felt like a fun exercise). Instead of building out a complicated UI for filtering the data and running the queries, I thought it would be a lot easier to just use a LLM to do all of that and just use a chat box.

Right now the built-in LLM runs on a single consumer GPU in my house and runs a pretty small Qwen model (tested best for generating the SQL queries) but I also have subscriptions to most of the AI providers, browser extensions installed for a lot of them and the "Ask Gemini" browser-provided UI for my Gemini subscription. Any one of these would be orders-of-magnitude better than the LLM I provide directly.

I can expose a WebMCP endpoint for everything the app-provided LLM uses and it should have 100% access to run the analysis engine but it doesn't feel like there are plans for how to make that a seamless experience for the user.

Optimally, registering the WebMCP tools would be able to trigger some sort of browser UI that lets the user pick a provider to use (extension or browser native UI) but it would be cleanest if I could know that the current user's browser had some way to handle that so I could offer UI to steer them to click a button to use their own LLM and hide the built-in chat window when the external chat is being used.

[heyitischris-web]

I think I follow most of what you are looking to do...why wouldn't you just use the AI capabilities JS function in your app? The reason why this is not really part of webmcp is because it is part of a different API in Chrome.

[heyitischris-web]

And you could also be speaking about imperative tool calling that runs async.

[pmeenan]

Sorry, I probably didn't explain it well.

The app

The app is a data exploration app. Specifically it loads the CVE dataset into a local sqlite database in the browser and lets the user explore the data. There is some basic filtering and raw SQL access but the primary way to work with the data is through a chat box that is LLM-powered and has access to in-page tools for querying the data, running arbitrary script (in a sandbox) and driving a charting engine.

Users can ask arbitrary questions in the chat box and it will either answer directly or use the charting tools to display the result.

AI Integration

The current chat box uses a self-hosted Qwen model running on infrastructure I manage (the term infrastructure is doing a lot of heavy lifting here, it's a single box with a consumer GPU). It's slow, doesn't scale well and isn't particularly good, but it is reliably good at tool calling and generating SQL so it works well for this project.

There are a bunch of other ways I could choose to integrate app-controlled AI (and have in other projects):

• Prompt API (large client download, questionable model capability)
• In-browser LLM using WebGPU (large client download, scales well but requires clients to have GPU's and go through the download)
• Use a LLM API endpoint with a paid API key (possible, but I'm cheap and the tool is free)
• Use LLM API endpoints with user-supplied keys (lots of user friction)
• Allow for custom LLM endpoints to be configured in the app (even more user friction and doesn't help the 99.9999% of people that don't run local LLM's or use one through API)

WebMCP

What WebMCP gives me is two things:

1 - Agent-driven browsing support: For anyone using the tool with pi, hermes, gemini spark, grok bot, whatever, they can use it to drive the site and explore the dataset through WebMCP.

2 - In-Browser AI chat interfaces. For anyone with a ChatGPT or Claude extension or some other AI chat extension or browser (or "Ask Gemini" if it ever gets page interaction support), the user can open the chat window and use their MUCH better models to explore the dataset using the same tools support that the in-app chat uses. This requires that the user actively open whatever chat interface they want to use and the in-page experience doesn't really adapt (in-page chat stays active).

What is missing

There's no real way to trigger the activation of browser/extension-provided chat/LLM support and integrate the external chat with the app experience cleanly from the app side.

In theory, just the presence of WebMCP might be a good signal to the browser or an extension to trigger and the app could find a way to react based on the usage of WebMCP API calls but that feels very fragile and doesn't really handle multiple providers being available, when/how to trigger them, or even a flow to direct users to install the extensions if they have subscriptions but no installed chat support.

Right now it feels like MCP is just a layer for driving the existing app capabilities and experience and is missing any way to better integrate browser/user-provided AI with the app experience directly.