Modern coding agents write code fluently, yet when the question is "why is this page slow," most of them can only stare at the source and guess. The Chrome DevTools team maintains a repository that changes that: ChromeDevTools/chrome-devtools-mcp, whose plain address is https://github.com/ChromeDevTools/chrome-devtools-mcp . The repository description reads Chrome DevTools for coding agents. It is an MCP server, and it lets a coding agent such as Antigravity, Claude, Cursor, or Copilot control and inspect a live Chrome browser. Agents used to stop at writing code; with it, an agent can open the performance panel, record a trace, and Debug the slowness itself. That shift is the subject of this article.
As of November 16, 2026, reading the GitHub API cumulative totals, the repository carries a stargazers_count of 57,033, a forks_count of 4,813, TypeScript as its primary language, and a license.spdx_id of Apache-2.0. The created_at field falls on 2025-09-11, and pushed_at reads 2026-11-15. The star figure is a cumulative total, not a single-day increment; pushed_at is the most recent push observed at the moment the fields were fetched, not a release date. Every number here can be checked directly on the repository page and the API. This article verifies only what the README, the LICENSE, the Releases feed, and the GitHub API can confirm; it adds no benchmarks on the project's behalf and treats no media retelling as a primary source.
The README states the position in one sentence: chrome-devtools-mcp lets your coding agent (such as Antigravity, Claude, Cursor or Copilot) control and inspect a live Chrome browser. It is available as a Model-Context-Protocol (MCP) server and as a CLI. One package, two forms, both aimed at giving an AI coding assistant the full power of Chrome DevTools for reliable automation, in-depth debugging, and performance analysis. The caller is a coding agent; the controlled object is a real, running Chrome, not a simulated snapshot of a page. The two forms split the audience without splitting the capability: the MCP server form serves agents wired into an MCP client, the CLI form serves terminals and shell scripts, and the README states that both give your AI coding assistant access to the full power of Chrome DevTools.
Three Capabilities: Performance Insights, Deep Debugging, Reliable Automation
The Key features section lists three items, all self-described. The first is performance insights: Uses Chrome DevTools to record traces and extract actionable performance insights. The server records a trace through Chrome DevTools and distills it into conclusions you can act on. The second is advanced browser debugging: Analyze network requests, take screenshots and check browser console messages (with source-mapped stack traces). Console stacks are source-mapped, so minified front-end code maps back to its original source locations instead of a wall of gibberish line numbers. The third is reliable automation: Uses puppeteer to automate actions in Chrome and automatically wait for action results. Puppeteer sits underneath, and actions wait for their results rather than firing and hoping.
Put the three together and the difference becomes concrete. What the agent receives is no longer a coarse action like "open this URL" but panel-level visibility into a real browser: every request in the network panel, every error in the console, a trace that can be analyzed in the performance panel. The workflow of a human opening the panel, recording a trace, reading the flame chart, and reporting conclusions back to the agent can now run end to end inside the agent itself. A trace is a full record of one real page load: how many requests fired, how long each took, where the main thread stalled. The agent's conclusions rest on recorded traces and extracted insights, not on its imagination about the code, and that is a different epistemic basis from writing code alone.
The Minimal Loop: One JSON Block, One Prompt, One CLI
Getting started requires one config block inside an MCP client:
{
"mcpServers": {
"chrome-devtools": {
"command": "npx",
"args": ["-y", "chrome-devtools-mcp@latest"]
}
}
}The @latest tag keeps the client on the newest version every time. After that, the first verification prompt is a single line:
Check the performance of https://developers.chrome.comOn receiving it, the MCP client should open the browser and record a performance trace. The README adds a note worth keeping: the server starts the browser automatically once the MCP client uses a tool that requires a running browser instance, and connecting to the server on its own will not start the browser. The same npm package also ships a chrome-devtools CLI for driving the browser from a terminal without MCP:
npm i chrome-devtools-mcp@latest -g
chrome-devtools navigate_page 1 --url "https://developers.chrome.com"
chrome-devtools take_screenshot 1 --filePath screenshot.png
chrome-devtools stopnavigate_page opens a page, take_screenshot saves an image, stop winds down. The requirements list is three items long: a Node.js LTS version, Chrome current stable or newer, and npm. Nothing else stands between installation and the first trace.
Privacy Defaults Are On: Three Defaults and Their Switches
This section deserves a careful reading, because plug-and-play has a second face. The Usage statistics section says plainly that Google collects usage statistics, such as tool invocation success rates, latency, and environment information, to improve reliability and performance, and that data collection is enabled by default. Three exits exist. Pass the --no-usage-statistics flag when starting the server. Set the CHROME_DEVTOOLS_MCP_NO_USAGE_STATISTICS environment variable. Or run in CI: collection is disabled when the CI environment variable is set.
The second default lives in the Disclaimers section: Performance tools may send trace URLs to the Google CrUX API to fetch real-user experience data. Presenting field data alongside lab data helps build a holistic performance picture, and passing --no-performance-crux turns the behavior off. The third default is the update check: by default the server periodically checks the npm registry for updates and logs a notification when a newer version is available, and setting CHROME_DEVTOOLS_MCP_NO_UPDATE_CHECKS disables it.
One subtlety is easy to miss. Google's collection of usage statistics for Chrome DevTools MCP is independent from the Chrome browser's usage statistics; opting out of Chrome metrics does not automatically opt you out of this tool, and vice-versa. Google also handles the collected data in accordance with its Privacy Policy, so the switches control whether collection happens at all, while the rules for the collected data live in that policy. Three defaults, four exits (--no-usage-statistics, CHROME_DEVTOOLS_MCP_NO_USAGE_STATISTICS plus CI, --no-performance-crux, CHROME_DEVTOOLS_MCP_NO_UPDATE_CHECKS), all written word for word in the README. Wiring this into production should start with reading that section and deciding how each switch should be set.
v1.13.0: logpoints and page-scoped network mocks
The release cadence has been steady. According to the GitHub Releases API fetched on 2026-11-16, v1.13.0 published on 2026-11-11 (published_at 2026-11-11T12:40:09Z), v1.12.0 on 2026-10-22, and v1.11.0 on 2026-10-15. The v1.13.0 release body highlights two features. One is logpoints, built on the DevTools BreakpointManager, which print to the console without pausing execution. The other is page-scoped network mocks, which limit mock responses to a single page. The same release adds upstream network mock responses, and its fixes include accepting configuration files with a UTF-8 BOM, truncating circular Error.cause chains at ten layers, and disabling set_logpoints under --no-javascript-evaluation.
For an agent, both features sharpen the granularity of debugging. Verifying the actual value of a variable inside a page used to mean injecting a script or editing code; a logpoint lets the page print the value itself. Checking how a front end behaves under a different server answer used to mean standing up a fake backend; a page-scoped mock lets the agent forge one network response inside a single page and watch the result.
Seven Built-in skills: A Manual Written for the Agent
The package does more than expose tools; it bundles seven skills that teach an agent how to use them. chrome-devtools debugs and automates pages with the MCP tools; chrome-devtools-cli runs the CLI and writes shell scripts with it; a11y-debugging audits and fixes accessibility issues; cookie-debugging debugs cookies, sessions, and authentication; debug-optimize-lcp debugs and improves Largest Contentful Paint; memory-leak-debugging finds and fixes memory leaks; troubleshooting fixes connection problems between MCP and Chrome.
Installation comes in two shapes. A plugin installs the MCP server and all skills together: Claude Code runs /plugin marketplace add ChromeDevTools/chrome-devtools-mcp followed by /plugin install chrome-devtools-mcp@chrome-devtools-plugins; Copilot and VS Code use Chat: Install Plugin From Source; Gemini CLI runs gemini extensions install --auto-update with the repository address. Agents without plugin support copy the skill folders from the npm package into their own skills directory. The README carries an IMPORTANT note worth quoting closely: skills describe the tools of a specific version, so update the skills each time you update the MCP server or the CLI, because outdated skills can tell your agent to use tools or parameters that changed. For teams that update the npm package regularly, treat the skill folders as part of the release step: update the package, copy the folders again, and only then let the agent run against the new version.
The Boundary: Chrome and Chrome for Testing, and an Agent That Can Touch Everything
The larger the capability, the more carefully the boundary should be read. The disclaimers say that chrome-devtools-mcp exposes content of the browser instance to the MCP clients allowing them to inspect, debug, and modify any data in the browser or DevTools, and they ask you to avoid sharing sensitive or personal information that you don't want to share with MCP clients. This is not boilerplate: login states, cookies, and local drafts are all within reach of the agent once the server is connected.
Browser support is equally explicit. The official wording is that chrome-devtools-mcp officially supports Google Chrome and Chrome for Testing only. Other Chromium-based browsers may work, but this is not guaranteed, unexpected behavior is possible, and use is at your own discretion. The support commitment covers the latest Extended Stable Chrome, meaning fixes and support are promised for that version line. Turning "other Chromium browsers may work" into "the official support list includes my browser" would exceed what the README says.
On the configuration side, the Configuration and Advanced Usage guides list the common flags: --headless for headless runs, --isolated for a temporary profile in one-off sessions, --slim to expose a reduced tool set when only basic browser tasks are needed, and --executablePath for a custom or non-standard browser path. Advanced options cover concurrent sessions, persistent user data directories, connecting to a running Chrome instance instead of starting a new one, and debugging on Android. For developers building agentic tooling, the README adds a recommendation of its own: to provide an integrated browser subagent as part of a product, build on top of Chrome DevTools for agents, with the Gemini CLI browser agent documentation as the reference implementation.
Stack the six layers together and the position of this Chrome's Official MCP Server is clear. Behind 57,033 cumulative stars stands a JSON block that opens the performance, debugging, and automation panels of Chrome DevTools directly to coding agents. Installation is minimal, but three defaults need the four switches when privacy matters; v1.13.0 sharpens debugging with logpoints and page-scoped network mocks; seven skills teach the agent to drive the tools correctly; and the boundary stays inside Chrome and Chrome for Testing. The title says it compactly: with Chrome's Official MCP Server, Agents Debug a Live Chrome. This article covers the browser-side repository itself, a different angle from the agent access boundaries in coding-agent-preview-access-boundaries-review and from the Office SDK in univer-office-sdk-agent-editing-opensource-resource.
FAQ
Q1: Can an agent really check performance by itself after setup? A1: Yes. After the MCP config is in place, send the prompt Check the performance of https://developers.chrome.com; the client opens the browser, records a trace, and returns actionable insights, and the browser starts automatically only when a tool that needs it is called.
Q2: Usage statistics are enabled by default. How do they go off? A2: Pass --no-usage-statistics when starting the server, set the CHROME_DEVTOOLS_MCP_NO_USAGE_STATISTICS environment variable, or rely on CI, where a set CI environment variable disables collection; the tool's statistics are also independent of the Chrome browser's own statistics.
Q3: Does the performance tooling send anything to Google? A3: It may. Performance tools may send trace URLs to the Google CrUX API to fetch real-user experience data, and --no-performance-crux disables that; update checks go off with CHROME_DEVTOOLS_MCP_NO_UPDATE_CHECKS.
Q4: Does it work on Edge or other Chromium browsers? A4: Official support covers Google Chrome and Chrome for Testing only. Other Chromium-based browsers may work, but this is not guaranteed, and the support commitment covers the latest Extended Stable Chrome; "may work" should not be read as "officially supported."
Q5: What should you watch after upgrading? A5: The seven bundled skills describe the tools of a specific version. Update the skills each time you update the MCP server or the CLI, otherwise the agent may call tools or parameters that changed, so treat the skill update as part of every upgrade step.
Related reading
- coding-agent-preview-access-boundaries-review: access boundaries for coding agents.
- univer-office-sdk-agent-editing-opensource-resource: an open-source Office SDK that lets agents edit cells.
- tsrs-rust-typescript-opensource-resource: open-source resources in the TypeScript ecosystem.
- github-ai-tools-metadata-comparison-review: a metadata comparison of GitHub AI tool repositories.