agent-eyes
agent-eyes is an MCP server that gives AI coding agents visual eyes on a real, invisible Chrome — screenshots, token-free layout/accessibility/design audits, pixel diffs against baselines, and proof that a fix actually reached the deployed site.
Capture screenshots at four named breakpoints (mobile 393×852, tablet 768×1024, desktop 1440×900, ultrawide 1920×1080) — one viewport, all four in one call, or a single cropped element — with token-cost controls (
format,quality,maxWidth,sizeMode); full-res always saved to disk, only a thumbnail on the wire.Label interactives with numbered badges over every clickable element and a legend mapping each number to a stable selector, so you pick targets off the picture instead of guessing selectors.
Run zero-image layout diagnostics across breakpoints: horizontal overflow, spill/clipping, truncated text, collisions, sub-44px tap targets, plus a width sweep that finds the real breakpoints the named viewports skip, and cold-load CLS measurement.
Measure a single element tokenlessly — dimensions, spacing, typography, composited colors, and a WCAG AA/AAA contrast verdict.
Scan accessibility: missing alt text, heading-order breaks, and form controls/buttons with no accessible name.
Audit design: measure the live design system and flag smells (too many fonts/colors, off-grid spacing, inconsistent radii), extract CSS-variable design tokens from any URL, or crawl a whole site into one consolidated design brief with CSS/Tailwind output.
Catch visual regressions: save and diff lossless PNG baselines with variance scores and delta overlays, plus a semantic region diff that hit-tests changed pixels back to the DOM elements that moved.
Interact and re-audit: click, type, hover, scroll, select, check, press keys, pointer gestures in viewport pixels (canvas/shadow-DOM/drag-and-drop), and blocking waits — as one interaction plus screenshot+audit, or a batched 25-step sequence with
expect_*assertions and in-pageevaluate_scriptreads.Verify a fix actually deployed: reloads the live URL and returns a per-check PASS/FAIL table (
noViewportOverflow,minTapTarget,fontSizeAtMost/AtLeast,exists/notExists), with a failed verdict marking the response an error for CI and verify-loops.Hand off to a human when only a person can act —
await_human_interactionopens the browser for a CAPTCHA/Turnstile and blocks until you click Done; it never solves or bypasses anti-bot protection.Log in without exposing credentials: the human types username/password/2FA into a localhost prompt and the server fills and submits them, returning only a status; credentials can also be stored in an encrypted AES-256-GCM vault for unattended logins, with status/reset/rekey management.
Manage session and tabs: seed cookies, localStorage and headers, snapshot/restore sessions, and keep multiple named tabs alive and switch between them.
Control the network: stub URL patterns with canned responses for deterministic captures, and wait for a specific response (optionally firing a trigger after the waiter is armed).
Generate an HTML audit gallery — a sortable contact sheet of every screenshot in a run with URL, viewport, tool, dimensions and issue counts.
Opt-in
evaluate_scripttool to run arbitrary JS in the page whenAGENT_EYES_ALLOW_EVAL=1is set.
Under the hood it drives your existing Chrome with no window (managed mode gives navigator.webdriver === false and a persistent logged-in profile), keeps one session alive across tool calls, and ends every response with a page-health block and a version tag.
Supports Google SSO sign-in flows, including clicking 'Continue with Google' and reusing an existing Google session, plus identifier-first login detection for Google-style authentication forms.
Drives a real local Google Chrome/Chromium browser via Playwright to capture screenshots, run layout/accessibility/design audits, interact with web pages, and perform visual regression checks without opening visible browser windows.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@agent-eyes Screenshot localhost:3000 at mobile and tell me what's overflowing."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
agent-eyes
Visual eyes for AI coding agents. An MCP server that lets your agent see and measure web pages instead of guessing at them: screenshots at real breakpoints, zero-image layout and accessibility audits, pixel diffs against committed baselines, and a check that a fix actually reached the deployed site.
It drives a real Chrome — invisibly. No window opens while your agent works; the browser only becomes visible when a human genuinely has to act, like solving a CAPTCHA. One browser session stays alive across tool calls, so state built up in step 1 still holds in step 9.
Install
One command. It detects your Chrome, writes a tuned .agent-eyes/settings.json, and adds the server to your agent's MCP config (keeping a backup of it):
npx -y github:oljodev/mcp-agent-eyes setup --agent claude-code --writeSwap --agent for cursor, codex, zed, or vscode. Drop --write to print the config instead of touching any file; drop --agent to see all five and where each config file lives. Restart your agent afterwards so it picks up the server.
agent-eyes installs straight from GitHub — there's no npm package to add and nothing lands in your global node_modules. The first run builds from source and can take a minute; after that npx caches it and startup is instant.
Update — one command, any time:
npx -y github:oljodev/mcp-agent-eyes updateIt compares your version with main, clears the cached copy (npx installs) or runs git pull + build (clones), and rebuilds. Restart your agent afterwards. update --check only reports, and exits 10 when a newer version exists. Running agents can read the same instructions from the agent-eyes://update MCP resource, and every tool response ends with [Metadata: agent-eyes vX.Y.Z] to compare against. Coming from v0.29 or older (no update command yet)? Run rm -rf ~/.npm/_npx once, then the command above works from then on. To stay on a release, pin a tag: github:oljodev/mcp-agent-eyes#v0.30.0.
Requirements: Node.js ≥ 20, and Chrome / Chromium / Edge (the installer tells you if it can't find one). Nothing is installed globally and no browser is downloaded — agent-eyes builds on playwright-core and drives the Chrome you already have.
Claude Code, in one line:
claude mcp add agent-eyes -- npx -y github:oljodev/mcp-agent-eyesOr edit the config by hand. The server command is npx -y github:oljodev/mcp-agent-eyes, or node /abs/path/to/mcp-agent-eyes/dist/index.js if you're running a clone.
Agent | Config file | Key |
Claude Code |
|
|
Cursor |
|
|
OpenAI Codex CLI |
|
|
Zed |
|
|
VS Code (Copilot agent) |
|
|
Claude Code / Cursor:
{ "mcpServers": { "agent-eyes": { "command": "npx", "args": ["-y", "github:oljodev/mcp-agent-eyes"] } } }VS Code:
{ "servers": { "agent-eyes": { "command": "npx", "args": ["-y", "github:oljodev/mcp-agent-eyes"] } } }Zed:
{ "context_servers": { "agent-eyes": { "source": "custom", "command": "npx", "args": ["-y", "github:oljodev/mcp-agent-eyes"], "env": {} } } }Codex:
[mcp_servers.agent-eyes]
command = "npx"
args = ["-y", "github:oljodev/mcp-agent-eyes"]Related MCP server: websight
First things to try
Just ask your agent in plain language — it picks the tools.
"Screenshot localhost:3000 at mobile and tell me what's overflowing."
No window opens. The full-resolution capture lands in .agent-eyes/captures/, a small thumbnail goes to the agent, and it answers with the elements whose right edge crosses 393 px.
"Check this page at every breakpoint and show me where the layout breaks."
matrix_responsive_audit shoots all four breakpoints in one call; detect_layout_matrix returns the diagnosis as text, with no images at all — overflow, collisions, tap targets under 44 px, unreadable font sizes.
"I fixed the hero on mobile — did it actually deploy?"
verify_fix reloads the live URL and returns a PASS/FAIL table, so "it works on my machine" gets checked against what's actually serving.
"This page shows a CAPTCHA — let me through, then continue."
await_human_interaction pops a window, you click, and the run resumes. The agent never solves it.
Why not just a screenshot MCP server?
Most browser MCP servers hand the agent a picture and stop. The picture is the expensive part of the loop: it burns tokens, and the agent still has to guess at numbers. agent-eyes is built around everything that happens after the screenshot.
typical screenshot MCP | agent-eyes | |
Measurement | agent eyeballs the image |
|
Regressions | "looks different?" |
|
Did it ship? | re-screenshot and squint |
|
Token cost | full-res image on the wire | full-res on disk, a small WebP thumbnail on the wire, many audits return no image at all |
Protected sites | automation fingerprint → blocked | real Chrome, |
When a human is needed | dead end |
|
Windows in your face | every call | none — a window appears only for a human handoff |
The tools
Four breakpoints are shared by every tool that takes one: mobile (393×852), tablet (768×1024), desktop (1440×900), ultrawide (1920×1080). Agents reason about them by name instead of inventing pixel sizes.
Capture
capture_page_screenshot (one breakpoint, with token-cost controls) · matrix_responsive_audit (all four in one call) · capture_element (cropped single element) · generate_audit_gallery (HTML contact sheet of a run)
Layout & measurement
audit (start here: CLS + layout at all breakpoints + accessibility + design smells in one zero-image report with a PASS/FAIL verdict) · detect_layout_matrix (zero-image DOM diagnostics across breakpoints, plus annotated renders) · find_breakpoints (where layout actually changes) · measure_element (tokenless inspector: dimensions, spacing, color, contrast) · measure_layout_shift (CLS) · visual_diff_regions (region-level pixel diff) · compare_to_baseline (save and diff visual baselines)
Accessibility
scan_accessibility — WCAG foundations: alt text, heading order, accessible names
Design
review_design (design-system audit and "smells") · extract_design_tokens ("steal this style" → CSS variables) · extract_site_design (whole-site summary)
Interaction
interact_and_audit (click/type/hover/scroll, then screenshot + audit) · run_interaction_sequence (batch steps, one capture at the end) · label_interactives (number every clickable thing on screen and return a legend of exact selectors) · wait_for_response (await a network response) · mock_route (stub responses for deterministic captures)
Human handoff — await_human_interaction
Session & tabs — manage_session (cookies / localStorage / headers / storageState) · manage_tabs
Verify — verify_fix
Opt-in — evaluate_script (run JS in the page; exposed only when AGENT_EYES_ALLOW_EVAL=1)
label_interactives paints a numbered badge over every interactive element in the viewport and returns the marked screenshot plus a legend mapping each number to a stable, unique selector and its accessible label. The agent picks the element off the picture by number, then acts on its exact selector — no selector guessing, no brittle nth-child. The overlay is removed after capture.
Both interaction tools also accept pointer gestures in viewport pixel coordinates read straight off a screenshot, so they reach anything visible regardless of DOM: shadow-DOM components, <canvas>/WebGL, maps, charts, drag-and-drop. pointer_click {x, y, button?} · pointer_hover {x, y} · pointer_drag {startX, startY, endX, endY, steps?}. Coordinates are bounds-checked against the current viewport.
run_interaction_sequence supports an evaluate_script step — far cheaper than an image when the agent just needs a count, some text, or a computed style:
run_interaction_sequence { "url": "…", "steps": [
{ "action": "evaluate_script", "script": "return document.title", "label": "page-title" },
{ "action": "evaluate_script", "script": "return document.querySelectorAll('a').length", "label": "link-count" }
] }The script runs as an async function body (use await; you must return a JSON-serializable value) and each result is surfaced under its label. This step is always available — distinct from the standalone opt-in evaluate_script tool, which still requires AGENT_EYES_ALLOW_EVAL=1.
Recipes
verify_fix — did the change actually deploy?
The flow that catches "the tool said fixed, but production still has the bug." It reloads the URL, so it reads the freshly deployed DOM rather than a stale tab, then evaluates small measurable assertions and returns a per-check verdict. A failure marks the whole response as an error, so verify-loops and CI notice.
verify_fix {
"url": "https://app.example.com",
"viewport": "mobile",
"checks": [
{ "selector": "h1.hero", "assert": "noViewportOverflow" }, // right edge ≤ viewport width
{ "selector": "h1.hero", "assert": "fontSizeAtMost", "px": 32 }, // the responsive font really shipped
{ "selector": "button.cta", "assert": "minTapTarget", "px": 44 }, // ≥ 44×44
{ "selector": ".old-banner", "assert": "notExists" }
]
}Assertions: noViewportOverflow, minTapTarget (px, default 44), fontSizeAtMost / fontSizeAtLeast (px), exists / notExists. Pass saveAs to snapshot the verdict under .agent-eyes/verify/.
Multiple tabs at once
Keep several real tabs open and switch by a label you assign — a preview in one, a staging site in another, neither losing its state.
manage_tabs { "action": "open", "label": "app", "url": "https://app.example.com" }
manage_tabs { "action": "open", "label": "test", "url": "https://staging.example.com" }
manage_tabs { "action": "list" } // → both tabs, which is active
manage_tabs { "action": "switch", "label": "app" } // every other tool now acts on "app"
manage_tabs { "action": "close", "label": "test" }Every other tool operates on the active tab. Calls are still serialized; multi-tab just means the other tab's state survives. The cap is tabs.maxOpen (default 8).
Human handoff & security model
agent-eyes does not log in for you and holds no credentials. Sign in by hand once — when a page needs a real human (a login, Cloudflare Turnstile, a CAPTCHA, an interstitial), await_human_interaction gives you a window (relaunching the invisible Chrome visibly, same profile, tabs reopened on their URLs) and blocks until you click Done or the page reaches an expected URL. The session then persists in the Chrome profile, so the agent reuses it. agent-eyes never solves the challenge and never bypasses anti-bot protection — it hands off to you, and your own click is what validates.
Full details, including what agent-eyes touches on your machine: SECURITY.md.
Configuration
Setup writes .agent-eyes/settings.json. It holds no secrets, so it's safe to commit and share with your team — it's intentionally not gitignored.
Key | Type | Default | Description |
|
|
| How the browser is obtained — see below. |
| string |
|
|
| string | null |
| Persistent Chrome profile for managed mode. |
| string | null |
| DevTools endpoint for |
| boolean |
| Leave the managed Chrome running after the server exits for an instant warm reconnect. Off by default so no Chrome (or its local DevTools port) lingers; sign-ins persist in the profile either way. |
| boolean |
| Managed mode only: run Chrome with no visible window ( |
|
|
|
|
| string[] |
| Extra Chrome flags, e.g. |
| number |
| Hard cap on concurrent named tabs. |
| number |
| Reserved for tuning the on-the-wire thumbnail width. |
Every setting has an environment-variable override, and env wins over the file: AGENT_EYES_BROWSER, AGENT_EYES_CHROME_PATH, AGENT_EYES_PROFILE_DIR, AGENT_EYES_CDP_URL, AGENT_EYES_CHROME_KEEPALIVE, AGENT_EYES_HEADLESS, AGENT_EYES_VISIBILITY, AGENT_EYES_CHROME_FLAGS. Point AGENT_EYES_CONFIG at a custom path to override discovery entirely.
Browser modes
managed(default) — agent-eyes launches and owns a real Chrome itself, raw-spawned rather than through Playwright's automation launch, sonavigator.webdriver === falseand Turnstile or Google sign-in treat it as a human browser. No manual commands, logins persist inprofileDir, and it runs with no window. The sole exception isawait_human_interaction, which relaunches it visibly so you can act; it stays visible for the rest of that session.headless— Playwright's headless Chromium. Fast and windowless, good for CI and pure auditing, but carries automation markers. Needsnpx playwright-core install chromiumonce.headed— a visible Playwright Chromium window. Still fingerprinted as automation; prefermanagedfor protected sites.cdp— attach to a Chrome you launched with--remote-debugging-port. An escape hatch;managedis the easy path.
agent-eyes always works in its own dedicated tab and never touches your other tabs or steals focus.
Where things are saved
Every screenshot-producing tool writes its full-resolution render to .agent-eyes/captures/run-<n>-<page>/ and reports the path, while only a small WebP thumbnail goes on the wire. An auto-generated .agent-eyes/.gitignore keeps captures/, gallery.html, and sessions/ out of git — baselines stay committable, so visual checkpoints can be shared with your team, and so does settings.json.
Every response ends with a page-health block (console errors, failed requests, 4xx/5xx, blank-page detection) and a [Metadata: agent-eyes vX.Y.Z] tag. Logs go to stderr only; stdout is reserved for the MCP protocol.
Troubleshooting
Symptom | Fix |
| Install Chrome/Chromium/Edge, or set |
Cloudflare Turnstile shows a "widget error" | You're not in managed mode — set |
Managed Chrome won't start in a container | Add |
|
|
| Start your dev server first. |
The agent says it has no tools | Restart your agent after editing its MCP config. |
| Your config names a bare package name. agent-eyes is installed from GitHub — the spec must be |
| The cached copy predates the |
Server fails to start the first time, works after | The first |
Development
git clone https://github.com/oljodev/mcp-agent-eyes.git
cd mcp-agent-eyes
npm install
npm run build # tsc → dist/
npm test # config, Chrome detection, verify assertsThe unit suite never launches a browser, so it runs anywhere. Point your agent at node /abs/path/to/dist/index.js to drive your working copy. Code layout, conventions, and PR expectations live in CONTRIBUTING.md.
Support
Bugs and ideas: open an issue — include your agent, your OS, and the
[Metadata: agent-eyes vX.Y.Z]line from a tool response.Security: report privately — see SECURITY.md. agent-eyes runs a real browser with your profile, so please don't file those in public issues.
What changed: CHANGELOG.md.
License
MIT © Olav Jodal
Available Tools
27 toolsauthenticate_loginLog in to a site without seeing the credentialsA
Log the user into a site with THEIR account, without the AI ever seeing the credentials. The human types username and password into a localhost secure page; the server fills them in, submits, and returns ONLY a status: success, otp_required (then call submit_2fa_code), error, push_wait, or unknown. Selectors are auto-detected when omitted, and the ones used are reported so a retry can correct them. NEVER returns a screenshot, since a 2FA or error page can render secrets — capture separately after success, then manage_session action=save. Blocks until the human answers the prompt or 180s elapse. The first sign-in to each new site asks for consent unless assumeConsent is set.
Inputs: profile (required), sso, flow, source, +6 more.
await_human_interactionHand the browser to the human to solve a challenge, then resumeA
Hand the live browser to the human for something the AI cannot or must not automate — a Cloudflare "Verify you are human" check, a CAPTCHA, an interstitial. It never solves the challenge and never bypasses anti-bot protection: it puts a window on screen, shows a localhost prompt with your reason and a Done button, and BLOCKS until the human clicks Done, the page reaches expectUrlContains, the human cancels, or timeoutMs elapses. Returns status (completed | cancelled | timeout) and the current url. The ONLY tool that shows a window: managed mode browses invisibly and is relaunched visibly here, so unsaved in-page state is lost. Headless mode returns a clear error instead of hanging.
Inputs: reason (required), timeoutMs, screenshot, expectUrlContains.
capture_elementCapture a single element (cropped screenshot)A
Screenshot ONE element, cropped to its bounding box — far cheaper than a full page when you only need a button, card, or nav. Navigates, applies the optional viewport, scrolls the selector's first match into view, and crops. The full-resolution crop is saved to disk; a webp thumbnail goes on the wire.
Inputs: url (required), selector (required), reload, viewport.
capture_page_screenshotCapture page screenshotA
Screenshot a URL at one breakpoint. Opens or navigates the persistent session — cookies, logins and page state survive across calls, and re-requesting the already-open URL does not reload it. The full-resolution render is always saved under .agent-eyes/captures/ and its path reported; format, quality, maxWidth and sizeMode control what the wire image costs.
Inputs: url (required), viewport (required), format, reload, +4 more.
compare_to_baselineVisual baseline: save or diffA
Visual regression checkpointing. set_baseline renders the URL at the given breakpoint and saves a lossless PNG baseline; diff_against_baseline re-renders and pixel-diffs against it, returning a variance score, dimension drift, and a red-on-grayscale delta overlay that is also saved to disk. fullPage covers the whole scroll height as a separate baseline. Scroll is reset to the top first, so earlier interactions cannot misalign the comparison.
Inputs: url (required), action (required), viewport (required), baselineName (required), +3 more.
detect_layout_matrixLayout diagnostics across all breakpoints (text-only)A
Zero-image layout diagnostics across all four breakpoints in one call. An in-page script measures the DOM and flags horizontal overflow, container spill or clipping, silently truncated text, destructive collisions, and sub-44px tap targets on mobile. Findings carry unique, addressable selectors. With annotate (default on), each breakpoint with findings also gets a red-outline render saved to disk and reported by path, costing no image tokens.
Inputs: url (required), reload, annotate, maxIssues, +1 more.
enroll_credentialsStore credentials in the encrypted vault (for unattended login)A
Save a profile's credentials to the encrypted vault (.agent-eyes/vault.json, AES-256-GCM) so later logins run with no human present: authenticate_login source=vault and submit_2fa_code source=totp pull from it. The human types every secret — the master passphrase, username, password, and with withTotp the authenticator seed — into the localhost prompt; the AI never sees any value. Optionally stores loginUrl and form selectors too. Returns a non-secret summary.
Inputs: profile (required), loginUrl, withTotp, otpSelector, +3 more.
extract_design_tokensSteal this style — extract design tokens from any URLB
Turn "make it look like " into a buildable spec: the palette with inferred roles (page background, surfaces, text, accent, accent gradient), the type scale, body size, weights and fonts, the spacing base and scale, radii and shadows — as an inferred-roles summary plus a pasteable CSS :root block. Optionally saved to .agent-eyes/styles/.
Inputs: url (required), reload, saveAs, viewport.
extract_site_designSteal this style — crawl a whole site into one design briefA
Crawl a handful of same-origin pages (nav links first) and return ONE consolidated design brief: the system merged across pages — fonts by role, color roles, type ramp, spacing, radii, shadows, ranked by cross-page frequency so the real system wins — plus each page's section anatomy and a pasteable CSS :root + Tailwind theme. Design and structure only, never copy, images, or logos.
Inputs: url (required), saveAs, maxPages.
find_breakpointsFind responsive breakpoints (width sweep)A
Zero-image responsive stress test: steps the viewport width from minWidth to maxWidth, probing horizontal overflow at each stop, and reports the exact width ranges where the layout breaks — the ones the four named viewports skip over. Restores the prior viewport afterwards.
Inputs: url (required), step, reload, maxWidth, +1 more.
generate_audit_galleryGenerate the audit gallery contact sheetA
Build .agent-eyes/gallery.html — a sortable contact sheet of every screenshot in a capture run, clean and annotated, each with URL, viewport, tool, selector, timestamp, dimensions and issue count, thumbnails linking to the full-resolution files. Aggregates every run unless you scope it to one. Returns the gallery path for a human to open.
Inputs: run.
interact_and_auditInteract with the page, then screenshot + auditA
Perform ONE interaction on the currently open page, then return a webp screenshot AND a fresh text layout audit of the resulting state, so breakage from an expanded menu, an active tab, or an opened modal shows up immediately. Gestures, blocking waits, and pointer gestures on viewport pixel coordinates are all available — see action for what each one needs. An ambiguous selector acts on the first match and says so. Pass viewport to switch breakpoints before the selector resolves, ignoreSelector to mute known layout noise. Open a page with capture_page_screenshot first.
Inputs: action (required), x, y, key, +16 more.
label_interactivesLabel interactive elements (set-of-mark)A
Set-of-mark prompting: paints a numbered badge over every interactive element in the viewport — links, buttons, inputs, selects, ARIA widgets, anything with a pointer cursor — and returns the marked screenshot plus a legend mapping each number to a stable, unique selector and its accessible label. Pick your target off the picture by number, then act on its exact selector with interact_and_audit. The overlay is removed after capture.
Inputs: url (required), reload, viewport.
manage_sessionManage auth/session state (cookies, storage, headers)A
Reach authenticated pages. set adds cookies, localStorage seeds and extra headers to the persistent session, applied to the live context and replayed onto any future one so they survive a crash. save snapshots cookies + localStorage to .agent-eyes/sessions/.json (gitignored — it holds plaintext tokens); load restores a snapshot by recreating the context, after which you navigate to use it; clear drops everything.
Inputs: action (required), name, cookies, headers, +1 more.
manage_tabsOpen and switch between multiple named browser tabsA
Keep several real tabs open at once and switch between them by a label you assign — a preview in one, a staging site in another, neither losing its state. open opens a named tab and makes it active, switch activates an existing one, close closes one (never the last), list returns each tab's label, url, viewport and active flag. Every OTHER tool acts on the ACTIVE tab. The default tab is "main".
Inputs: action (required), url, label.
manage_vaultManage the encrypted credential vault (status / reset / rekey)A
Keep the credential vault recoverable. status reports whether a vault exists, whether it is unlocked, and its profile names — never secrets. reset permanently DELETES the vault after the human types RESET into the secure prompt, the escape hatch for a forgotten passphrase; re-enroll afterwards. change_passphrase re-encrypts every profile under a new one.
Inputs: action (required).
matrix_responsive_auditResponsive audit across all breakpointsA
Capture one URL at all four breakpoints in a single call, webp-compressed to keep a four-image turn affordable (sizeMode "thumb" shrinks it further). All four full-resolution renders are saved to one run directory and their paths reported; the previously active viewport is restored afterwards.
Inputs: url (required), reload, fullPage, sizeMode.
measure_elementMeasure an element (tokenless inspector)A
Zero-image element inspector: one element's live rendering spec from getComputedStyle and getBoundingClientRect — dimensions, position, typography, computed padding and margin, and ancestor-composited foreground/background colors with a WCAG AA (4.5:1) / AAA (7:1) contrast verdict including the large-text relaxation. Verifies design-system and a11y specs without image tokens.
Inputs: url (required), selector (required), reload, viewport, +1 more.
measure_layout_shiftMeasure Cumulative Layout Shift (CLS)A
Cold-load CLS diagnostic: arms a layout-shift observer BEFORE the page parses, reloads, watches ~2s, then reports the aggregate score (good ≤ 0.10, poor > 0.25) and the exact elements that jumped, ranked by attributed shift — jank no static screenshot shows. Zero image tokens. Rebuilds a pristine page, discarding any in-page state.
Inputs: url (required), maxCls, viewport.
mock_routeStub network routes for deterministic capturesA
Stub matching requests with canned responses, so flaky or third-party endpoints cannot change what you capture. add registers a URL glob → {status, contentType, body, headers}; clear removes stubs by pattern or all; list shows the active ones. Stubs are context-level: they survive navigations and a crash until cleared. Only sub-resources can be mocked, never the top-level navigation.
Inputs: action (required), body, status, headers, +2 more.
review_designDesign review — measure the design system + flag smellsA
Zero-image DESIGN audit — the taste counterpart to scan_accessibility. Measures the page's actual design system (palette, type scale, weights and families, spacing rhythm, radii, shadows) and flags design smells: too many font sizes or colors, off-grid spacing, cramped or over-long or sub-16px body text, inconsistent radii, near-miss alignment — each with an addressable selector.
Inputs: url (required), reload, viewport, maxSmells.
run_interaction_sequenceRun a multi-step interaction sequenceA
Batch pipeline for multi-step flows such as forms and nested menus: navigates, optionally matches a viewport, then runs the steps in one fast loop and returns ONE screenshot plus ONE layout audit after the final step — far cheaper than chaining interact_and_audit. Steps mix gestures, waits, expect_* assertions and evaluate_script, so a single call can drive AND verify a flow. A failing gesture or wait aborts at its index with earlier steps applied; failed expect_* checks let the flow finish but mark the whole response a FAILURE.
Inputs: url (required), steps (required), reload, sizeMode, +2 more.
scan_accessibilityAccessibility scan (text-only)A
Zero-image WCAG foundation audit of the live DOM. Flags missing alt (or empty alt not declared decorative), heading hierarchy breaks (h2 → h4, or a document whose first heading starts deeper than h2), and inputs, selects, textareas and buttons with no computable accessible name — placeholders do not count. Grouped text report with unique, addressable selectors.
Inputs: url (required), reload, viewport, maxIssues.
submit_2fa_codeEnter a 2FA code without seeing itA
Complete a two-factor challenge raised by authenticate_login, without the AI ever seeing the code. The human types the current one-time code into a localhost secure page; the server fills the auto-detected code field, submits, and returns ONLY a status: success (then manage_session action=save), error, or unknown. Acts on the page authenticate_login left behind and never navigates. Blocks until answered or 180s elapse.
Inputs: source, profile, codeSelector, submitSelector.
verify_fixVerify a change actually landed on the live pageA
Confirm a fix REACHED the deployed site rather than a stale local tab. Reloads the URL by default, evaluates small measurable assertions per element, and returns a per-check PASS/FAIL table of measured vs expected plus an overall verdict — a failed verdict marks the response an error, so verify-loops and CI catch it. This is what catches "the tool said fixed but production still has the bug".
Inputs: url (required), checks (required), reload, saveAs, +1 more.
visual_diff_regionsSemantic visual diff (element-resolved regression)A
Visual regression that points at code, not pixels: diffs the current render against a saved baseline, clusters the changed pixels into regions, and hit-tests each against the live DOM — so you get "button.cta-primary — 1,240 changed px" instead of "3.2% of pixels changed". A delta overlay is saved to disk. Requires a baseline from compare_to_baseline with matching fullPage.
Inputs: tag (required), url (required), reload, fullPage, +2 more.
wait_for_responseWait for a network response (optionally around a trigger)A
Wait for a network response whose URL matches a pattern, and report its status, method, content-type and size, plus an optional body snippet. An optional trigger interaction fires AFTER the waiter is armed, so a fast response cannot be missed (click Save, await POST /api/save). On timeout it lists the responses it did see, to help fix the pattern. Acts on the open page.
Inputs: urlPattern (required), trigger, timeoutMs, includeBody.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 27 tools
Many tools overlap in purpose (capture_page_screenshot vs matrix_responsive_audit vs capture_element, compare_to_baseline vs visual_diff_regions, scan_accessibility vs review_design). Detailed descriptions help differentiate them, but an agent could still hesitate between similar-sounding audit and capture tools.
Tool names consistently follow a clear verb_noun snake_case pattern (authenticate_login, capture_element, manage_session, scan_accessibility). Even multi-word names like compare_to_baseline and run_interaction_sequence maintain the same grammatical style and predictable structure.
27 tools is a large surface for a single server, exceeding the 25+ threshold. While many serve distinct QA purposes, the set feels heavy compared to typical well-scoped servers, and several tools could be consolidated (e.g., baseline/diff tools, multiple audit tools).
The tool surface covers the full browser QA lifecycle: authentication, session persistence, screenshots, interaction, responsive layout, accessibility, design extraction, visual regression, network mocking, and verification. Minor gaps exist (e.g., no explicit DOM text extraction or page source tool), but agents can work around them with existing gestures and evaluate_script steps.
Maintenance
Related MCP Connectors
Website checker for AI coding agents. Measures your site in a real browser, with evidence.
Browser-based QA for AI-built software. Test pages with real browsers via agents.
Hosted browser for AI agents: screenshots, post-JS DOM, console, WCAG. No install, no API key.
Give AI agents a real cloud Chrome: open sessions, navigate, read pages, click, type and screenshot.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceEnables AI agents to automate and debug real Chromium browsers with capabilities like screenshots, video recording, performance analysis, visual regression testing, and OCR text extraction.13-
- AlicenseNot gradedqualityDmaintenanceEnables AI agents to see, analyze, and visually verify web page changes through pixel-perfect diffing, theme extraction, layout analysis, and interactive element detection.9 npmMIT
- AlicenseNot gradedqualityDmaintenanceEnables AI coding agents to visually interact with frontend apps by taking screenshots, clicking elements, reading console logs, and performing visual diffs.6 npm3MIT
- AlicenseAqualityBmaintenanceEnables AI agents to capture screenshots, scrape structured page content, and run automated visual checks on live websites via a headless Chromium browser.3MIT