Skip to main content
Glama

agent-eyes

CI node license

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 --write

Swap --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 update

It 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-eyes

Or 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

~/.claude.json (global) or .mcp.json (project)

mcpServers

Cursor

~/.cursor/mcp.json or .cursor/mcp.json

mcpServers

OpenAI Codex CLI

~/.codex/config.toml

[mcp_servers.agent-eyes]

Zed

~/.config/zed/settings.json

context_servers

VS Code (Copilot agent)

.vscode/mcp.json

servers

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

measure_element returns real px, spacing, and WCAG contrast — zero images

Regressions

"looks different?"

compare_to_baseline / visual_diff_regions — pixel diffs against committed baselines

Did it ship?

re-screenshot and squint

verify_fix reloads the deployed URL and returns a PASS/FAIL assertion table

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, navigator.webdriver === false, persistent profile

When a human is needed

dead end

await_human_interaction opens a window, you click, the run resumes

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

browser.mode

"managed" | "headless" | "headed" | "cdp"

"managed"

How the browser is obtained — see below.

browser.chromePath

string

"auto"

"auto" detects a real Chrome; or give an absolute path.

browser.profileDir

string | null

null

Persistent Chrome profile for managed mode. null → ~/.agent-eyes/chrome-profile. Anything you sign into lives here.

browser.cdpUrl

string | null

null

DevTools endpoint for mode: "cdp" (e.g. http://localhost:9222).

browser.keepAlive

boolean

false

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.

browser.headless

boolean

true

Managed mode only: run Chrome with no visible window (--headless=new), keeping the real-Chrome fingerprint and your logged-in profile. A handoff relaunches the same profile with a window and reopens your tabs, so only unsaved in-page state is lost. Set false to see the window from the first capture.

browser.visibility

"on-demand" | "always"

"on-demand"

on-demand: never steal focus — only await_human_interaction puts a window on screen. always: keep a visible window foregrounded (implies headless: false).

browser.extraFlags

string[]

[]

Extra Chrome flags, e.g. ["--no-sandbox"] in containers.

tabs.maxOpen

number

8

Hard cap on concurrent named tabs.

captures.thumbnailMaxWidth

number

1024

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, so navigator.webdriver === false and Turnstile or Google sign-in treat it as a human browser. No manual commands, logins persist in profileDir, and it runs with no window. The sole exception is await_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. Needs npx playwright-core install chromium once.

  • headed — a visible Playwright Chromium window. Still fingerprinted as automation; prefer managed for protected sites.

  • cdp — attach to a Chrome you launched with --remote-debugging-port. An escape hatch; managed is 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

Managed browser mode could not find Google Chrome

Install Chrome/Chromium/Edge, or set browser.chromePath to the executable.

Cloudflare Turnstile shows a "widget error"

You're not in managed mode — set browser.mode: "managed" for a real, clean Chrome.

Managed Chrome won't start in a container

Add "--no-sandbox" to browser.extraFlags, if you trust the environment.

Chromium is not installed for Playwright

npx playwright-core install chromium. Only headless/headed need a downloaded browser; managed mode uses your system Chrome.

Nothing is listening at http://localhost:…

Start your dev server first.

The agent says it has no tools

Restart your agent after editing its MCP config.

npm error 404 … mcp-agent-eyes

Your config names a bare package name. agent-eyes is installed from GitHub — the spec must be github:oljodev/mcp-agent-eyes.

update hangs or just starts the server

The cached copy predates the update command (≤ v0.29). rm -rf ~/.npm/_npx once and retry.

Server fails to start the first time, works after

The first npx run builds from source and can outlast your agent's MCP startup timeout. Run the install command once in a terminal, then restart your agent.


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 asserts

The 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 tools
authenticate_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.

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

    A3.8/5.0

    Scored across 27 tools

    Disambiguation3/5

    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.

    Naming Consistency5/5

    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.

    Tool Count2/5

    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).

    Completeness4/5

    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

    ActivitySlowing
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers