Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Fix the driver behind crashes, sound loss and screen glitches3Repair Windows errors before they cause bigger problemsSome links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.
Implement WebMCP by exposing a small, well-defined set of page actions as tools: use document.modelContext.registerTool() for custom JavaScript and single-page-app workflows, or the Declarative API when an existing HTML form already expresses the action. Start with one user journey, define a constrained input schema, mark the tool’s risk accurately, and keep the ordinary UI working as a fallback. WebMCP is a proposed standard—not a universally available production API—so plan for browser support and origin restrictions before shipping.
What WebMCP changes in an app
WebMCP lets a webpage expose structured tools to browser-based AI agents. Instead of asking an agent to infer that a particular button means “search the catalog,” then simulate clicks and interpret the resulting page, the site can describe an action, its inputs, and its result explicitly. Chrome for Developers describes WebMCP as a proposed web standard and a progressive enhancement; it is intended to improve reliability for supported browser-agent interactions, not replace a site’s normal interface.
A tool is an explicit capability made available by a page, not a general-purpose grant to control the user’s account. A search tool might accept a query and return matching items. A booking or purchase tool can change state and therefore calls for tighter inputs and a visible confirmation flow. The agent’s access is still constrained by the page’s origin and browser support, and content returned by a tool can still be untrusted.
Choose the first journey and API
Pick one bounded task
Choose a task with a clear user goal, inputs, and result. Good starting candidates include catalog search, order-status lookup, filtering, appointment booking, support-form completion, date selection, travel booking, or diagnostics. Avoid beginning with a broad “operate the site” tool: an agent and a user should be able to tell what the capability does from its name and description.
#1 Best Overall
Write down the action’s expected inputs, whether it changes data, what successful completion means, and which page or account state makes it available. This short contract helps decide whether the operation belongs in the declarative or imperative API and gives you a checklist for tests.
Choose declarative for a real form; imperative for app logic
Use WebMCP’s Declarative API when a standard HTML form already expresses the action and its submission flow. That is the simpler fit when the form is the contract. Use the Imperative API when the journey depends on custom JavaScript, SPA state, navigation, or application functions rather than a straightforward form submission. The overview also notes experimental Angular support; React, Next.js, Vue, and other frameworks can use the underlying JavaScript API in a browser-capable client context.
Framework choice does not change the core requirements: register from code running in the browser, tie registration to the state in which the action is valid, and remove stale capabilities when that state ends. Do not register during server-side rendering or assume a server component has access to document.
Register an imperative tool
The following minimal pattern adapts the documented registerTool() contract. It is a read-only catalog search example: replace the illustrative endpoint and response shape with your app’s actual API. It limits returned results and passes the supplied cancellation signal to fetch.
const mc = document.modelContext;
if (mc) {
await mc.registerTool({
name: "search_catalog",
description: "Search the product catalog by a text query.",
inputSchema: {
type: "object",
properties: {
query: { type: "string", description: "Text to search for" }
},
required: ["query"]
},
execute: async ({ query }, { signal }) => {
const response = await fetch(`/api/catalog?q=${encodeURIComponent(query)}`, { signal });
if (!response.ok) throw new Error("Catalog search failed");
const data = await response.json();
return JSON.stringify({ items: data.items.slice(0, 20) });
},
annotations: {
readOnlyHint: true,
untrustedContentHint: true,
consequentialHint: false
}
});
}The if (mc) check lets the application continue to render when the API is unavailable. A real page should also keep its normal search form or controls available: WebMCP is an enhancement for compatible agents, not a prerequisite for ordinary visitors. The example assumes the endpoint returns JSON with an items array; validate that assumption against your API and handle malformed or unexpected data rather than forwarding it unchecked.
Make the tool contract clear and bounded
Tool names and descriptions are part of the interface an agent must interpret. Use a specific verb-and-object name, a description that states the outcome, and a JSON Schema that rejects missing or ambiguous inputs. If the action has a finite set of valid choices, constrain it with an enum; make genuinely required inputs required instead of hoping the agent guesses them.
Chrome’s security guidance recommends keeping descriptions to no more than 500 characters, parameter descriptions to 150 characters, tool or parameter names to 30 characters, and an individual tool output to 1.5K characters. Treat these as design limits for concise, useful contracts, not as a reason to truncate meaningful results without a plan. Return only the fields the agent needs, and paginate or offer a narrower follow-up tool when the full result set is too large.
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Annotations should match behavior
Set readOnlyHint to true only when execution does not change state. Set consequentialHint for irreversible or high-stakes actions, including purchases, bookings, transfers, and deletion. Set untrustedContentHint when results include user-generated or external content. These hints communicate risk; they do not enforce authorization, validate business rules, or make dangerous behavior safe by themselves.
Handle actions that change state
Do not combine discovery and commitment into an ambiguous tool such as “do whatever is needed to book.” A safer design separates a narrow operation from a user-visible confirmation step. For example, a tool may gather availability or prepare a booking request, while the application displays the selected details and requires the user to confirm before the server commits it.
Validate permissions and business constraints on the server as well as in the browser. The agent’s proposed arguments are not proof of user intent or authority. Apply the same authentication, ownership, pricing, availability, and validation rules you would apply to a normal form submission. If a tool can have a material effect, make that effect apparent in the UI before it happens.
Manage registration in SPAs and frameworks
In a single-page application, a tool should exist only while its action is valid. Register it when the relevant route or authenticated state becomes active, and remove it when the user navigates away, signs out, or loses the required state. The Imperative API documents removal using an AbortController, and execution receives a cancellation signal for long-running work.
Keep the controller associated with the component, route, or state owner that created the registration. On cleanup, abort or remove the registration using the API’s documented lifecycle mechanism. Also pass the execution signal to cancellable network work, as in the example, so that an agent cancellation does not leave unnecessary requests running. Do not keep a tool registered with stale account-specific data merely because the page shell remains mounted.
For React or similar frameworks, perform registration in a client-side lifecycle, not during render. For Next.js, that means code must run in a browser-capable client context. Framework wrappers may have different lifecycle syntax, but the essential behavior remains registration on entry and cleanup on exit; use the framework’s cleanup mechanism and verify that it does not register duplicates after rerenders.
Check browser support and origin policy
WebMCP is proposed and under active discussion, so its API and support can change. Chrome’s current documentation describes joining the origin trial documented from Chrome 149, or enabling chrome://flags/#enable-webmcp-testing for local development. A local flag is a development aid, not evidence that ordinary users’ browsers have the capability. Keep the non-WebMCP path functional, and check the current Chrome documentation and trial requirements before relying on a particular release or availability window.
WebMCP requires an origin-isolated document. The tools Permissions Policy defaults to self; a cross-origin iframe needs allow="tools" to enable the capability there. If you use exposedTo, list only trusted HTTPS or localhost origins. Insecure or invalid origins can cause a SecurityError. Avoid broad exposure: any origin granted access should be one you would already trust with the same data or authority.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Repair Windows errors before they cause bigger problemsFix Now →Test tools before release
Use Chrome’s Model Context Tool Inspector to inspect registrations, manually invoke tools, validate schemas, and review structured results and errors. Exercise the tool with normal inputs, missing required inputs, invalid values, empty results, API failures, and cancellation. Confirm that a result has the shape and size your agent-facing contract promises.
The in-page getTools() and executeTool() APIs are useful for embedded agents and automated test harnesses. A page does not need to call them merely to expose tools to browser agents. Test both the WebMCP path and the regular user interface, including cases where the API is absent, registration fails, or the user changes route or account state while work is in progress.
Security and trust boundaries
WebMCP does not make page content trustworthy. A tool description, tool result, or ordinary webpage content can contain indirect prompt-injection instructions. Treat user-generated text and external page data as data, not as trusted directions to an agent. Mark such outputs untrusted, keep them bounded, and avoid mixing them with instructions in ways that make their origin unclear.
Rank #4
Chrome’s guidance recommends limiting input tokens, restricting origins, confirming consequential actions, highlighting or delimiting untrusted text, scanning descriptions and outputs, and using an intent-alignment critic when risk warrants it. The right defenses depend on the action: a public catalog lookup and an account deletion should not receive identical permissions or confirmation treatment. A read-only tool can still expose private information, while a read-write tool can act on a user’s behalf.
PC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteImplementation checklist
- Purpose: the name and description identify one concrete user goal.
- Inputs: the schema requires needed values and constrains valid options.
- Risk: read-only, consequential, and untrusted-content annotations reflect actual behavior.
- Output: only necessary information is returned, and external or user text is treated as untrusted.
- Confirmation: state-changing actions have an explicit, visible confirmation path.
- Origin: isolation and Permissions Policy work in the actual embedding context.
- Lifecycle: registration is removed when route or account state changes.
- Validation: the Inspector and automated tests cover expected results, invalid input, errors, and cancellation.
- Fallback: the ordinary browser UI remains usable when WebMCP is unavailable.
Or skip the browser setup
If your goal is capturing a webpage for visual review rather than exposing app actions to browser agents, ScreenshotNeo is a separate website screenshot API and MCP server; it does not implement WebMCP. One GET request can return an image or PDF. See the ScreenshotNeo API documentation for parameters and response details.
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpScreenshotNeo accepts cookie and consent banners before capture and removes more than 60 known consent platforms, newsletter popups, and chat widgets; each step can be turned off. Bot checks, blank pages, timeouts, failed loads, and cache hits are not billed, and responses identify the page verdict and billing status. Its MCP server provides take_screenshot, get_page_info, and capture_pdf for Claude, Cursor, and other MCP clients. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000 shots. Visit ScreenshotNeo or sign up free for 1,000 screenshots a month with no card.
Common implementation problems
The tool does not appear
First check that code is running in the browser and that document.modelContext exists in the browser configuration you are testing. Confirm the documented trial or local flag is enabled, registration completed, and the Inspector is examining the correct page and origin. In an unsupported browser, provide the ordinary UI rather than assuming a missing tool means the user journey is broken.
A cross-origin embed cannot expose its tool
Check that the document meets the origin-isolation requirement and that the iframe’s Permissions Policy permits tools. The default is self; a cross-origin iframe needs allow="tools". If using exposedTo, verify every listed origin is valid, HTTPS or localhost, and trusted. An invalid or insecure origin may result in SecurityError.
Registration fails after navigation or duplicates appear
Review the SPA lifecycle: tie each registration to one route or user state, and remove or abort it during cleanup. Check that rerenders do not register the same tool repeatedly and that account-specific tools are not left active after sign-out or a route change.
The agent sends invalid arguments or receives unusable results
Tighten the JSON Schema: declare required fields, constrain choices where appropriate, and make descriptions specific. Then invoke the tool through the Inspector with missing, malformed, and valid values. Bound output size, validate upstream data, and return a concise structured result instead of an unbounded page payload. Errors should be understandable without exposing secrets or internal details.
Best Value
A cancelled or consequential operation behaves unexpectedly
For long-running execution, honor the cancellation signal and pass it to operations such as fetch that support cancellation. For state changes, separate preparation from commitment and require an in-app confirmation before the irreversible step. Do not treat an annotation as a substitute for server-side authorization or confirmation.
Performance, reliability, and rollout
WebMCP’s main reliability benefit is a more explicit action contract than DOM inference and simulated clicks; the reviewed implementation guidance publishes no performance percentage or adoption figure. Keep tools narrow and responses small to limit unnecessary work, and avoid exposing expensive or broad operations when a focused query will do. The example’s bounded result count is illustrative; select limits based on the application’s own requirements.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Roll out as progressive enhancement: retain the same underlying application rules and usable conventional workflow, enable the capability for supported environments, then monitor registration, execution, cancellation, and error paths with your existing application diagnostics. Recheck Chrome’s documentation before each release because this proposed standard is evolving. Treat trial or flag access as preview support unless the browser’s current terms and availability establish otherwise.
Frequently Asked Questions
Does a site need to implement both the Declarative and Imperative APIs?
No. Pick the API that matches the action: a standard form can use the Declarative API, while custom JavaScript and SPA behavior suit the Imperative API.
Does WebMCP make an AI agent’s input safe to execute?
No. Validate inputs, enforce authorization and business rules in the application, and require confirmation where an action is consequential.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
