Google's chrome-devtools-mcp Hands AI Agents the Chrome DevTools They Were Missing
Brutal! GitHub 56k Stars: Let AI Directly Control Chrome Debugging
Author: 狂师
Tags: 前端, 人工智能, 测试

Today we're talking about a project: chrome-devtools-mcp. Many people likely already know about it.
It comes from Google's official ChromeDevTools organization. Chrome DevTools and Puppeteer are both managed by this team. It was open-sourced in September 2025, and in over a year the star count has grown to 56,000.
What it does is simple, one sentence: It packages the entire debugging power of Chrome DevTools into an MCP server, letting an AI agent connect directly to a real Chrome instance to check requests, browse the console, and record performance traces for you.
For this project, you only need to remember a few key points.
- Project:
chrome-devtools-mcp, official nameChrome DevTools for agents - Produced by: ChromeDevTools organization, official maintainers of Chrome DevTools panel and Puppeteer
- Stars: 56,390 (as of 2025-11-15), open-sourced September 2025, latest version v1.13.0 released last week
- Tech stack: TypeScript + Puppeteer + Chrome DevTools Protocol, one npm package with both MCP server and CLI usage
- License: Apache-2.0

People who write frontend with AI should install this the most
Anyone who has written frontend with AI knows this cycle. The agent finishes a page, it runs but shows a blank screen. You open DevTools yourself, look at the console errors, see which request in the Network tab turned red, copy the error, paste it back into the chat, wait for the agent to fix it, run it again, paste again.
The agent can't see any of this debugging information and can only guess from the code. You copy and paste error messages back and forth, and a single blank-screen debugging session can run up dozens of chat rounds.
chrome-devtools-mcp hands DevTools directly to the agent. After installation, you can just give it a one-line task. The official docs provide three examples.
Open the mobile version of developer.chrome.com, tap the hamburger menu, and check whether all top-level navigation items are present. Simulate location to Berlin and see if the store locator page can find the Rosenthaler Strasse store. Run a Lighthouse accessibility audit, list all elements with insufficient contrast, and give fix suggestions.
The agent opens the browser itself, clicks, looks at results, and hands back a report. You only do the acceptance check.

50+ tools, divided into three layers by what the agent can do
Chrome DevTools MCP bundles 50+ capabilities, split into three layers based on the agent's responsibility:
- Layer 1 is the browser interaction base, letting the agent open pages, click and type, simulate mobile/weak network and other access environments.
- Layer 2 is the diagnostic collection layer, opening DevTools' network, Console, performance, memory, and style panels to the agent for data collection.
- Layer 3 is high-level decision orchestration, where the agent uses real runtime information from the browser to autonomously reproduce bugs, locate frontend issues, and coordinate with a code agent to complete fix verification.

In addition to 50+ tools, it also comes with 7 built-in Skills
Besides the 50+ atomic tools, Chrome DevTools MCP includes 7 built-in Skills.

Simple distinction: Tools are individual low-level actions you can call; Skills are pre-defined troubleshooting flows and strategy methods given to the agent, telling it how to sequence tool calls and interpret results when it encounters a certain type of problem.
| Skill Name | Core purpose | Typical use / applicable scenarios |
|---|---|---|
| chrome-devtools | General debugging main entry, default Skill, provides basic browser operations and page observation | Page error reproduction, UI automation, network request inspection, DOM checks, screenshots, Lighthouse general audits; prioritize for most frontend debugging scenarios |
| chrome-devtools-cli | Guides agent to generate reusable CLI command scripts, packaging browser operations into command lines | CI pipeline automation, batch tasks, output debugging scripts directly runnable in the terminal |
| a11y-debugging | Accessibility-specific debugging, guides agent to use DevTools accessibility panel for compliance checks | WCAG acceptance, ARIA attribute validation, contrast, focus management, screen reader compatibility issues |
| cookie-debugging | Focuses on Cookie, frontend storage, and session auth observation and modification | Login state loss, cross-domain SameSite Cookie issues, LocalStorage/SessionStorage debugging, auth token anomalies |
| debug-optimize-lcp | LCP (Largest Contentful Paint) performance investigation, records performance traces to locate bottlenecks | Slow initial load, Core Web Vitals optimization, image/font/server response blocking analysis, SEO experience optimization |
| memory-leak-debugging | JS memory leak diagnosis, guides heap snapshot capture and comparison to locate leaked objects | SPA page memory keeps rising during navigation, long-running page jank, detached DOM, event listeners not released, etc. (requires --memoryDebugging) |
| troubleshooting | MCP self-diagnosis for connection issues, investigates Chrome-MCP service connectivity | MCP can't connect to Chrome, attach fails, timeouts, browser launch args/port/permission anomalies |
The 7 Skills are not separate install packages; they are bundled with chrome-devtools-mcp, so you don't need to download and install them individually.
But they come in two access modes:
- Install only the MCP service (just the 50+ low-level Tools, no Skills);
- Install the Plugin mode (MCP service + all 7 Skills loaded together, so the agent can read those debugging flows).
In addition, some specific capabilities require adding a startup flag to unlock their companion tools.
One config to connect to your Agent
Environment requirements are two: Node.js LTS version and a current stable Chrome. Add a block to your MCP client config:
{
"mcpServers": {
"chrome-devtools": {
"command": "npx",
"args": ["-y", "chrome-devtools-mcp@latest"]
}
}
}
If you want to enable the memory-leak Skill's heap snapshot tool, add the --memoryDebugging parameter:
{
"mcpServers": {
"chrome-devtools": {
"command": "npx",
"args": [
"-y",
"chrome-devtools-mcp@latest",
"--memoryDebugging"
]
}
}
}
Note: The raw JSON config mode is pure MCP by default, without Skills; if you want Skills, prefer the Plugin approach below.
If you use Claude Code, you can install via plugin, bringing both MCP and skills at once:
/plugin marketplace add ChromeDevTools/chrome-devtools-mcp
/plugin install chrome-devtools-mcp@chrome-devtools-plugins
Codex users, one command:
codex mcp add chrome-devtools -- npx chrome-devtools-mcp@latest
Once configured, drop a prompt to verify:
Check the performance of https://developers.chrome.com
The agent automatically launches Chrome when it calls the first tool, records a performance trace, and gives optimization suggestions when done. When you see the browser pop up by itself, it's working.
This npm package actually comes in two forms: besides the MCP server, there's also a chrome-devtools CLI. If you don't want to hook up an agent, you can also use it directly in the terminal:
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 stop
Too many tools? Add --slim at startup to keep only the basic operations group. For beginners, just remember two sets: navigate and screenshot to get the flow running, console and network to debug bugs. The performance and memory batches can wait until you actually need them.

Before using, two things to know
First, the browser's content is fully exposed to the MCP client. The agent can see any data and page inside that Chrome instance. Don't connect your daily Chrome with company backends and saved passwords. The official disclaimer says this plainly. Browser support is also only guaranteed for Google Chrome and Chrome for Testing; other Chromium-based browsers might work, but if something breaks, don't expect official support.
Second, usage statistics are collected by default. Data such as tool call success rates and latency get sent back to Google. If you want to disable it, add the --no-usage-statistics startup parameter.
The performance tool also sends trace URLs to Google's CrUX API to pull real user data. If that bothers you, add --no-performance-crux.
Final words
The trade-off of such tools is clear. If you have AI agents writing frontend daily and are tired of pasting errors back and forth, connecting this saves real time. If you only occasionally tweak static pages, it's optional.
Even if you don't install it, two ideas are worth taking away. Tools you give an agent shouldn't stop at "can operate"; "can see the result" is far more useful. An agent that can read console, network, and traces produces vastly better work than one that can only click.
Also, the official team packaging their panel's analysis engine as MCP tools for agents is a practice that any team with professional accumulated expertise could follow to expose their most useful and reusable capabilities. That in itself is worth recommending more than any specific tool.
Two links are here for anyone interested.
Project repository:
https://github.com/ChromeDevTools/chrome-devtools-mcp
Official docs:
https://developer.chrome.com/docs/devtools/agents