BLOG
Agentdeskai/Browser Tools MCP: Setup and Remote Browsers
Learn how agentdeskai/browser tools mcp connects an AI client to Chrome DevTools, and what to check before using hosted Chromium.

agentdeskai/browser tools mcp connects an MCP-compatible AI client to browser debugging information through a Chrome extension and a local server. It is useful when an assistant needs to inspect a page while you develop: for example, reviewing console errors, network activity, screenshots, or selected elements.
The important distinction is that this project is not simply a remote Chromium endpoint. Its extension and server must be able to communicate with the browser being inspected. A hosted browser with Chrome DevTools Protocol (CDP) access can be part of a browser-agent stack, but a CDP URL alone does not establish compatibility with the Browser Tools extension.
What AgentDeskAI Browser Tools MCP does
AgentDeskAI’s Browser Tools MCP repository describes a browser-inspection workflow built around three components:
- An MCP server exposes browser-related tools to an MCP client.
- A browser-tools server acts as an intermediary for browser data.
- A Chrome extension captures information from the browser’s developer-tools environment.
The client is the application hosting the AI assistant. It discovers the MCP server’s tools and lets the assistant invoke them. The extension observes the browser, and the intermediary helps move data between the extension and the MCP-facing component.
This architecture is particularly relevant for frontend debugging. An assistant working on a UI issue may need to see an error in the console, inspect a selected element, or understand why a network request failed. Browser Tools is designed around making that context available to the assistant rather than asking a developer to copy every detail manually.
The exact tools, package versions, installation commands, and configuration options can change. Use the repository’s current README as the source of truth for the release you install, and inspect the tool list exposed by your MCP client after connecting.
What it is not
Browser Tools MCP is not the same thing as:
- An MCP client: The client connects to the server and makes its tools available to an assistant.
- A hosted browser: Chromium still needs to run somewhere, whether on your workstation or in a compatible remote environment.
- A CDP endpoint: CDP provides a protocol for controlling and inspecting Chromium; it does not automatically load the Browser Tools extension.
- A general-purpose agent framework: An agent or client still decides which tools to call and how to use the results.
That distinction matters when you move beyond a local development setup. The browser location, extension support, and network path to the intermediary all become deployment decisions.
Browser Tools MCP architecture: local vs. hosted
A typical local setup keeps the components close together:
AI client
│ MCP
▼
Browser Tools MCP server
│
▼
Browser-tools intermediary ◄── Chrome extension / DevTools
│
▼
Local browser pageWith hosted Chromium, the browser and the extension—if the runtime supports loading it—would run remotely. The extension must still reach the correct intermediary. An address such as localhost refers to the extension’s own machine or container, not automatically to your laptop.
| Concern | Local Chrome workflow | Hosted Chromium workflow |
|---|---|---|
| Browser location | Developer workstation | Remote runtime |
| Extension installation | Usually controlled by the developer | Requires explicit runtime support |
| Intermediary address | Often reachable on the same machine | Must be reachable from the remote browser environment |
| DevTools access | Developer can open Chrome DevTools directly | Depends on the runtime’s UI and extension support |
| Browser access | Local browser and profile permissions | Provider session credentials and isolation controls |
| Best fit | Interactive debugging during development | Remote agent execution or shared infrastructure, after compatibility checks |
Do not assume that a live viewer is a Chrome DevTools window. A viewer can show a remote page without exposing the extension’s DevTools panel. Check both capabilities independently before choosing this architecture.
Set up agentdeskai/browser tools mcp locally
Start locally to establish that the client, intermediary, and extension work together. Then evaluate any remote deployment as a separate integration.
1. Review and install the project components
Follow the installation steps in the project repository. Pay attention to the version-specific instructions for:
- The MCP server package and its runtime requirements.
- Starting the browser-tools intermediary.
- Installing the Chrome extension.
- Opening the extension’s panel in Chrome DevTools.
- Configuring your MCP client to launch or connect to the server.
Pin the versions you test in team documentation or a lockfile where applicable. Avoid copying old commands from unrelated tutorials: the MCP server, intermediary, and extension need to be compatible with one another.
2. Connect the MCP client
Add the server to your client using that client’s MCP configuration format and the project’s current launch instructions. Restart or reload the client if required.
Then verify that the client lists the server’s tools. A connected process is not enough: confirm the tools are discoverable and that a call returns useful browser data.
Keep the server’s standard output reserved for its MCP transport if the client uses a standard-input/output connection. Unexpected debug output on that stream can interfere with protocol messages; direct diagnostic logs to the appropriate channel for the server.
3. Attach the extension to a test page
Open a page you control, open Chrome DevTools, and follow the project’s instructions for activating its extension panel. Use a disposable test page rather than a production account for the first run.
Generate an obvious signal, such as a test console error or a request to a known endpoint. Ask the MCP client to retrieve the relevant information using the tools it exposes. Check that the returned result corresponds to the correct tab and recent action.
For network testing, avoid sending real credentials or personal data. Headers, URLs, request bodies, and response bodies can contain secrets.
4. Test the complete round trip
A useful acceptance test has three parts:
- Create an observable event: Trigger a console message or a failing request on the test page.
- Retrieve it through the client: Invoke the corresponding available MCP tool.
- Validate the result: Confirm the event belongs to the expected tab and time window.
If the client sees tools but receives no browser data, investigate the extension, DevTools panel, intermediary process, and their network path before changing the model prompt.
Can Browser Tools MCP use a remote browser?
Possibly, but only if the remote environment supports the project’s extension-based workflow. Hosted Chromium and CDP access are not, by themselves, proof that agentdeskai/browser tools mcp will work with a particular session.
Before attempting the integration, answer these questions:
- Can the hosted browser load the required Chrome extension?
- Can you open and operate the extension’s DevTools panel in that environment?
- Can the extension reach the browser-tools intermediary over the required network path?
- Can you secure that path without exposing a debugging service publicly?
- Does the extension attach to the intended tab and session?
- Are the extension and intermediary versions compatible?
If any answer is no or unknown, treat the integration as unverified. A local Chrome setup may be the simpler choice for interactive Browser Tools debugging.
For remote automation, there is another option: connect an automation library to hosted Chromium over CDP and collect the specific diagnostics your application needs. That is an alternative architecture, not a drop-in replacement for Browser Tools MCP. You would need your own MCP server or another tool interface if an AI client must invoke those capabilities through MCP.
Test a hosted Chromium session over CDP
The following TypeScript example is a standalone connectivity and diagnostics check. It does not install AgentDeskAI’s extension, start its intermediary, or expose MCP tools. It demonstrates how to attach Playwright to an existing Chromium session and capture console messages and failed requests.
Install Playwright in your project, then set CDP_ENDPOINT to the WebSocket or HTTP endpoint supplied for your hosted Chromium session:
npm install playwright
export CDP_ENDPOINT='wss://YOUR_PROVIDER_CDP_ENDPOINT'import { chromium } from "playwright";
async function main(): Promise<void> {
const endpoint = process.env.CDP_ENDPOINT;
if (!endpoint) {
throw new Error("Set CDP_ENDPOINT to your Chromium CDP endpoint.");
}
const browser = await chromium.connectOverCDP(endpoint);
const context = browser.contexts()[0];
if (!context) {
throw new Error("The connected browser has no accessible context.");
}
// Use a new tab so the check does not navigate an existing one.
const page = await context.newPage();
page.on("console", (message) => {
console.log(`[console:${message.type()}] ${message.text()}`);
});
page.on("requestfailed", (request) => {
console.error(
`[request failed] ${request.url()}: ` +
`${request.failure()?.errorText ?? "unknown error"}`,
);
});
try {
await page.goto("https://example.com", {
waitUntil: "domcontentloaded",
timeout: 30_000,
});
console.log(`Title: ${await page.title()}`);
console.log(`URL: ${page.url()}`);
} finally {
await page.close();
}
}
main().catch((error: unknown) => {
console.error(error instanceof Error ? error.message : error);
process.exitCode = 1;
});Run the example with your preferred TypeScript runner or compile it as part of your project. Use a test URL you are authorized to access.
The endpoint should be treated like a credential: anyone who can use it may be able to control the browser session. Do not commit it to source control or print it in logs. CDP connections also have different capabilities and limitations from Playwright’s native protocol; see the Playwright `connectOverCDP` documentation.
Closing the tab in this example does not replace provider-specific session cleanup. End the hosted session through your provider’s documented lifecycle so it does not remain active unnecessarily. For Remote Browser connection details, see the documentation.
Production criteria for browser inspection
Whether you use agentdeskai/browser tools mcp locally or build a separate remote diagnostics path, decide what data the assistant can access and how long that data survives.
Session and tab isolation
Associate every diagnostic event with the correct browser session and tab. A shared intermediary or a browser with several open tabs can otherwise return misleading context. For multi-user workloads, use isolated sessions and make sure one user cannot inspect another user’s browser activity.
Persistent profiles can be useful for authorized workflows that need a saved login. They also retain sensitive state. Restrict profile access, separate profiles by user or workload, and define a process for revoking them.
Network exposure
The MCP server, intermediary, extension, and hosted browser may run in different network locations. Document each connection and its direction before deployment.
Do not expose an unauthenticated intermediary or CDP endpoint to the public internet. Use your organization’s approved network controls and authenticated access mechanisms. If the extension expects a loopback address, remember that loopback belongs to the remote environment when the extension runs there.
Data collection and retention
Console output and network traces can include authentication tokens, query parameters, user identifiers, and application data. Screenshots can reveal the same information visually.
Collect only the signals needed for the task. Redact or filter sensitive fields before sending them to a model or storing them, and set retention rules for logs and screenshots. Review access to live browser sessions as carefully as access to recorded artifacts.
Lifecycle and failure handling
Define what happens when the MCP client disconnects, the intermediary restarts, or the browser session expires. A retry should not silently repeat an action that changes data, such as submitting a form or purchasing an item.
For hosted sessions, track session creation, connection failures, duration, and cleanup. Check current pricing and usage limits before sizing a workload; local development and continuously running remote sessions have different cost profiles.
Where Remote Browser fits
Remote Browser provides hosted Chromium sessions with CDP access, compatibility with Playwright, Puppeteer, and Selenium, plus a live viewer, persistent profiles, session isolation, usage controls, and configurable browser settings.
It can serve as the runtime for a remote browser-agent workflow or a custom CDP-based inspection service. It should not be assumed to support the AgentDeskAI extension workflow without verifying extension loading, DevTools access, and intermediary connectivity for your deployment.
Use agentdeskai/browser tools mcp when its Chrome extension and debugging workflow match how your team works. Use a hosted runtime when the browser itself needs to run remotely, with controlled sessions and a defined lifecycle. If you need both, validate the integration end to end before making it a dependency of your production workflow. For more on the runtime layer, see remote browsers for AI agents.