Designers MCP server
com.allthepossibles/designersallthepossibles.comstreamable-httpv1.1.0Scanned
Checks, prompts and skills for designers working with AI: contrast, a11y, heuristics, critique.
141 tools: 125 change things and 16 only read.
- Reads private data · 3
- Reads text others write · 34
- Can send data out · 34
- 21 findings
Tools listed without sign-in. Remote posture
With Anlyon
125 tools here change things. Govern them.
- Anlyon lists the tools and adopts none.
- Each tool you adopt gets approvals and receipts.
- Your agent never holds the key.
A tool your agent calls directly is not routed through Anlyon and is not governed by it. Anlyon Radar only lists and labels, and these labels are the same either way.
What the Designers MCP server can do
The Designers MCP server is published by allthepossibles.com, a domain the MCP Registry verified. It has 141 tools. It can create or change data (125 tools: check_contrast, audit_page_accessibility, heuristic_worksheet, detect_design_slop and 121 more), but cannot delete data. 16 tools only read.
3 tools read private data (screen_reader_script, rendered_vs_static_notes and print_file_checklist); 34 tools bring in text other people can write (audit_page_accessibility, heuristic_worksheet, detect_design_slop and 31 more); 34 tools can send data out of your system (audit_page_accessibility, heuristic_worksheet, detect_design_slop and 31 more). On its own it has all three parts of a prompt-injection exfiltration path: private data, text others write, and a way out.
The fixed checks matched 21 findings (annotation-conflict). Each one comes with the text it matched.
Its remote endpoint lists its tools without sign-in, and its tools changed once since Anlyon Radar first saw them.
Last scanned Nov 11, 2026, version 1.1.0.
Tools
Grouped by what each tool does, most consequential first. Open one for its reasons and full description; descriptions are the publisher's own words.
141 tools
Changes things 125Claude Code: ask
approx_print_colourApproximate between sRGB and CMYK.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Approximate between sRGB and CMYK. Pass `value` as hex (#1a2b3c), rgb(26,43,60) or cmyk(60,40,40,100). Returns the other model by a plain formula (K = 1 - max(R,G,B); C = (1 - R - K) / (1 - K); and R = 255 x (1 - C)(1 - K) back), total ink, and gamut cautions. This ships NO Pantone or other licensed color data: if you pass a spot name such as 'PANTONE 485 C', it tells you to look the value up in your licensed swatch book or Adobe's libraries and paste the RGB or CMYK here. APPROXIMATION ONLY: real conversion needs an ICC profile and the paper; the printed color will differ. Proof it.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
audit_dark_patternsAudit screen copy, HTML or a public URL for deceptive-design (dark pattern) signals: confirmshaming, forced continuity and hard-to-cancel flows, pre-selected options, false urgency…Reads text others writeCan send data outNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Description, as the server wrote it Audit screen copy, HTML or a public URL for deceptive-design (dark pattern) signals: confirmshaming, forced continuity and hard-to-cancel flows, pre-selected options, false urgency and fake scarcity, misdirection by visual weight, hidden costs, trick questions and double negatives, nagging, forced action or registration, disguised ads, obstruction, and social proof without a source. Give text (one string per line, optional prefixes like button:, link:, checkbox:), and/or html, and/or url. Markup signals include checked inputs, a prominent accept button beside a quiet decline link, countdown timers and cancel flows longer than sign-up flows. Each finding has severity, the evidence string and a fix, and echoes frameworks in general terms (FTC negative option guidance, EU Digital Services Act and Consumer Rights Directive, CPRA). Signals for review, not a legal finding.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
audit_email_accessibilityAccessibility audit of marketing or transactional email HTML.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Accessibility audit of marketing or transactional email HTML. Pass the full source as `html`. Checks layout tables missing role=presentation, missing lang and title, images without alt or with decorative alt mistakes, image-only emails and likely text in images, vague link text such as "click here", font sizes under 14px, low-contrast inline color pairs, missing preheader, fixed width over 600px, heading structure, color-scheme declaration, estimated tap-target height of table-built buttons, and reading-order risks in multi-column tables. Email clients differ and this reads markup only: it does not render the email, resolve <style> classes for color, or confirm a plain-text alternative. Each finding names the WCAG criterion and a fix.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
audit_formAudit a form's markup and its error messages, with extra care for sign-up and payment forms.Reads text others writeCan send data outNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Description, as the server wrote it Audit a form's markup and its error messages, with extra care for sign-up and payment forms. Pass `html` or a public `url`, and optionally `errors` (error message strings, one per line). Checks programmatic labels and placeholder-only labels (WCAG 1.3.1, 3.3.2, 4.1.2), autocomplete tokens on personal data fields (1.3.5), wrong input types and inputmode for phone, email, card and one-time codes, password fields that block paste or lack a show-password option, required fields not marked in text or in aria, fieldset and legend on radio and checkbox groups, error wiring (aria-describedby, aria-invalid, live regions, error summary), disabled submit buttons, CAPTCHA without an alternative (3.3.8), and redundant entry (3.3.7). Each error string is checked for saying what happened, saying how to fix it, blame, jargon, the word invalid, and generic wording. Findings carry criterion, severity and fix. Reads static markup only; color-only errors and script-built fields need a browser check.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
audit_icon_setAudits a set of inline SVG icons.1 finding
Why it is in this group
- The name "audit_icon_set" says "set": a word for a change.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Findings
- Warn
The server marks "audit_icon_set" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The name "audit_icon_set" says "set": a word for a change.
Description, as the server wrote it Audits a set of inline SVG icons. Pass `icons` as markup containing one <svg> (or <symbol>) per icon. Reports mixed viewBox sizes, missing viewBox, non-square boxes, width and height ratios that disagree with the viewBox, mixed outline and solid styles, stroke widths and linecap or linejoin that vary, hard-coded colors instead of currentColor, icons neither aria-hidden nor named (WCAG 1.1.1), icons with both, ids repeated across icons, path points outside the viewBox, and icons that fill the artboard very differently from the median. Path extents use command endpoints only and only <path> data. Stroke and grid expectations are conventions. Static; nothing is rendered.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
audit_motion_cssAudit pasted CSS for motion problems.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Audit pasted CSS for motion problems. Pass `css` (stylesheet text with @keyframes, animation and transition rules). Optional flash data you measured or know from the design: `flashes_per_second`, `flash_area_percent` (share of the screen that flashes). Flags: animation or transition of layout properties (width, height, top, left, margin, padding, font-size and similar, which force layout), paint-heavy properties, `transition: all`, animations or transitions with no matching prefers-reduced-motion rule, infinite animations with no animation-play-state or pause control in the CSS (WCAG 2.2.2), long durations, and flashing risk against WCAG 2.3.1 (more than three flashes in any one second, unless the flashing area is small). Flash rate from CSS is estimated from the animation duration and cannot see luminance change. Static analysis only.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
audit_page_accessibilityAudit one page's static HTML for accessibility problems and name the WCAG 2.2 criterion for each: missing lang or title, images without alt, unlabeled form fields, vague or empty l…Reads text others writeCan send data outNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Description, as the server wrote it Audit one page's static HTML for accessibility problems and name the WCAG 2.2 criterion for each: missing lang or title, images without alt, unlabeled form fields, vague or empty links and buttons, heading jumps, no main landmark, zoom-blocking viewport, autoplay with sound, tabindex above zero, duplicate ids, click handlers on non-interactive elements, tiny inline targets. It reads markup only and cannot test contrast, focus order or script-built widgets.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
audit_site_accessibilityPro.Reads text others writeCan send data outNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Description, as the server wrote it Pro. Crawl up to 15 same-origin pages from a start URL, audit each one's static HTML for WCAG 2.2 problems, and report issues by how many pages they affect so that shared-template problems come first. Returns a markdown report.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
audit_spacingAudit spacing in a stylesheet.Reads text others writeCan send data outNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Description, as the server wrote it Audit spacing in a stylesheet. Pass `css` (free) or a public `url` (Pro). Reads margin, padding and gap properties (shorthands split into their parts; rem and em converted with the root size the CSS sets; auto and 0 skipped), then reports the detected base unit (8 if 85% of uses fit, else 4, else none with the best fit), the number of distinct values against a budget of 12, off-grid values with counts, gaps between steps, values used once, the split between margin, padding and gap, and a proposed scale with an old-to-new table. Percent, vw, calc() and clamp() values are counted as fluid and left out of the scale.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
audit_token_scalesAudit the scales behind a set of design values.Reads text others writeCan send data outNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Description, as the server wrote it Audit the scales behind a set of design values. Pass `css` (free), a public `url` (Pro), or `values` (JSON with any of colors, fontSizes, spacing, radii; each a list of strings, or {value, count} objects). Reports: colors within deltaE 2 of a more used color (with the one to keep), font sizes, spacing and radii within 1px of each other, values that sit off the detected 4px or 8px grid, gaps between steps, values used exactly once, and a proposed consolidated scale with a table mapping every changed old value to its new value. Mappings snap to the nearest standard step and should be checked on screen before applying.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
audit_type_scaleAudit a stylesheet's typography.Reads text others writeCan send data out1 finding
Why it is in this group
- The name "audit_type_scale" says "type": a word for a change.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Findings
- Warn
The server marks "audit_type_scale" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":true}; The name "audit_type_scale" says "type": a word for a change.
Description, as the server wrote it Audit a stylesheet's typography. Pass `css` (free) or a public `url` (Pro). Reads font-size, the font shorthand and line-height, converts rem and em with the root size the CSS sets, and reports: every size with its use count, the modular ratio that best explains the sizes (major second to octave, with the share of sizes it covers) or that none fits, sizes that fall off that ratio, pairs less than 2px or 10% apart, the number of distinct sizes against a budget of 8, the body size (under 16px is flagged, under 14px is high), text under 12px, and line heights that are tight, loose or wrong for the size. Fluid sizes written with clamp() or vw are counted but not placed on the scale.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
brand_architecture_plannerSuggest a brand architecture model per product.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Suggest a brand architecture model per product. Give `products` as lines 'Name | audience=same | category=overlap | risk=low | standalone=no | acquired=no' (or objects with those keys) and optionally `company`. audience and category take same, overlap or different relative to the parent; risk is the chance a problem with one damages the other (low, medium, high); standalone says whether it needs an identity that can live alone; acquired says whether you bought it. Returns branded house, house of brands or endorsed brand for each with scores, the reasons, which facts were missing and treated as neutral, an example naming pattern, and an overall tally with a note when the portfolio is mixed. Scoring is our own simple rule, a starting point for discussion.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
brand_voice_consistencyCheck brand voice consistency across samples.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Check brand voice consistency across samples. Give `samples` (a list, or text with samples separated by a line of ---, or by blank lines; 2 to 40) and optionally `rules` (plain lines or JSON: banned words, 'use X not Y', capitalisation of names, punctuation bans, max sentence length, required terms) and `bannedWords`. Returns per-sample sentence length (mean, spread, longest), contractions, you/we use, a 0 to 100 formality score from transparent measures, drift flags where a sample is 15+ formality points or 35% in sentence length from the set, rule violations by sample, and required terms that never appear. Heuristic, English only; it compares samples with each other, not with a standard.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
build_gridBuild a column grid from page or container width.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Build a column grid from page or container width. Pass `width`, and optionally `columns` (default 12), `gutter` (default 24), `margin` (default 24). Returns the column width, the x position of every column, the width of every span from 1 to N columns, CSS grid code (fixed pixel and fluid fr versions), and the Figma layout grid settings. Flags fractional column widths and suggests the nearest widths that give whole pixels. For a modular grid, also pass `rows` and `height`; optionally `rowGutter` (defaults to the gutter) and `baseline` (line height in px). The modular result gives module size, row positions, CSS, and whether module height plus row gutter lands on whole baseline lines, with the module height that would fix it (a convention). Rejects zero, negative, NaN and layouts where the columns do not fit. Sources: Müller-Brockmann, Grid Systems in Graphic Design; Samara, Making and Breaking the Grid; Marcotte, Responsive Web Design. Pure arithmetic, nothing stored.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
build_heuristic_reportPro.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Pro. Build a scored, exportable markdown report from heuristic evaluation findings you have written. Each finding has heuristic (1 to 10), severity (0 to 4), location, issue, effect, fix and optional effort (S, M, L) and evaluator. Merges duplicates across evaluators, computes a health score, and sorts a fix-first table.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
build_spacing_scaleGenerate spacing tokens from a base unit.1 finding
Why it is in this group
- The description's first verb is "generate": a word for a change.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Findings
- Warn
The server marks "build_spacing_scale" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The description's first verb is "generate": a word for a change.
Description, as the server wrote it Generate spacing tokens from a base unit. Pass `base` (px, default 8) and one of: nothing (linear 4/8-point ladder: half step, 1x, 1.5x, 2x, 3x, 4x, 5x, 6x, 8x ...), `ratio` (modular: base times ratio to the power n, starting at the base), or `steps` (your own list of px values). `count` sets the token count (default 10, max 18 for linear and 24 for modular). Each token returns px, rem at 16px, a usage line (hairline gap, inside a component, component padding, between siblings, between groups, between sections), and a flag when the value is not a whole multiple of the base or is a fractional pixel. Also returns CSS custom properties in rem and in px, with an optional `prefix` (default space). Sources: Samara, Making and Breaking the Grid (consistent units); Graver and Jura, Best Practices for Graphic Designers (modular scales). The 4 or 8 point unit itself is a convention. Pure arithmetic, nothing stored.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
button_label_consistencyCheck a list of interface labels for consistency.1 finding
Why it is in this group
- The name "button_label_consistency" says "label": a word for a change.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Findings
- Warn
The server marks "button_label_consistency" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The name "button_label_consistency" says "label": a word for a change.
Description, as the server wrote it Check a list of interface labels for consistency. Give `labels` (one per line; repeat a label once per place it appears so counts are real) and optionally `groups` (your own synonym sets, one per line, comma separated). Groups labels that name the same action from a built-in list of about 17 actions (sign in/out/up, delete, cancel, save, edit, add, next, back, buy, view, download, search, send, share, confirm), suggests the most-used label as the standard, and flags mixed Title Case and sentence case, all capitals, inconsistent end punctuation and generic labels. Some groups depend on context; merge only where the action is truly the same.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
calc_fitts_hickEstimate movement time with Fitts's law (Shannon form: a + b * log2(distance / width + 1)) and decision time with the Hick-Hyman law (a + b * log2(choices + 1)).No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Estimate movement time with Fitts's law (Shannon form: a + b * log2(distance / width + 1)) and decision time with the Hick-Hyman law (a + b * log2(choices + 1)). Pass `distance` and `width` for one target, `choices` for a choice set, and/or `layouts`: 2 or 3 layouts, each {name, targets: [{label, distance, width}], choices} to compare total time. Constants are configurable with `fitts_a`, `fitts_b`, `hick_a`, `hick_b` (milliseconds; defaults a=100, b=150 for pointing and a=200, b=150 for choice, typical illustrative values). These are models: the defaults are not measured on your users, so use results to compare layouts, not to predict seconds. Sources: Fitts 1954, MacKenzie's Shannon formulation, Hick 1952, Hyman 1953, as context in Cooper's About Face and Norman. Constants and laws are stated from general knowledge, not verified against the design library.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
calc_print_resolutionCalculate resolution for print.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Calculate resolution for print. Pass print `width` and `height` with `unit` (mm, cm, in), optional `viewing_distance` with `distance_unit` (cm, in, m) and optionally `pixels_w`, `pixels_h` of the image you have. Formulas: pixels = size in inches x ppi; the ppi a viewer can resolve at distance d is 1 / (2 d tan(0.5 arcminute)) which is about 3438 / d(inches), assuming normal 20/20 vision resolves 1 arcminute; effective ppi = pixels / size in inches. Returns pixels needed at the acuity-suggested ppi (capped at 300) and at 300 ppi, and, if you give pixel dimensions, the effective ppi and a verdict. 300 ppi is the usual figure for work held in the hand; large format is viewed from farther away and can go lower. The vendor's stated minimum wins. 'DPI' here means image pixels per inch.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
calc_print_specWork out print document sizes.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Work out print document sizes. Pass `trim_width` and `trim_height` with `unit` (mm, cm, in, pt), optional `bleed` (default 3 mm; the common European figure, US printers often ask 0.125 in = 3.18 mm), `safe` margin inside trim (default 5 mm), and for books `pages` (counted as printed pages, 2 per leaf), `caliper` (thickness of ONE sheet of the paper) with `caliper_unit` (microns, mm, mil = thousandth of an inch, which paper trade calls points, or in), `spine_extra_mm` for glue allowance, and `binding` (perfect, saddle, none). Formulas: size with bleed = trim + 2 x bleed; safe area = trim - 2 x safe; spine = (pages / 2) x caliper + extra; cover spread width = 2 x trim width + spine + 2 x bleed. Spine is an estimate: the printer's own template and paper stock win, and hardcover case binding adds board thickness not computed here.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
calculate_proportionWork out proportions.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Work out proportions. Pass `ratio` (golden, root2 or a-series, root3, any a:b such as 3:2 or 16:9, or a decimal such as 1.414; default golden) and `width` or `height`. Optionally `orientation` (landscape by default, or portrait) and `container` (length to split; defaults to the long side). Returns the missing side, the split of the container into a major and minor part at that ratio (with CSS fr and px forms), a table of heights at the same width for ten common ratios, and, when you give both width and height as a source image, centered crop sizes and offsets for the target ratio and common alternatives with the share of area kept. Root-2 is the ISO A-series ratio, where folding a sheet in half keeps its shape. Sources: Graphic Design Solutions (golden section); Samara, Making and Breaking the Grid; Müller-Brockmann, Grid Systems in Graphic Design. That any one ratio is more beautiful is a convention, not a finding. Pure arithmetic, nothing stored.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
chart_chooserPick a chart type from the question being asked and the shape of the data.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Pick a chart type from the question being asked and the shape of the data. Pass `question` (compare, trend, distribution, part-to-whole, relationship, ranking, geography) and any of: `categories` (number of groups or items), `points` (observations or time steps), `series` (number of series), `thirdVariable` (relationship questions: a third measure to encode), `hierarchy` (parts nest inside parts), `overTime` (the question is across time), `audience` (general or analyst). Returns `ranked` chart types, each with a reason tied to your numbers, `avoid` (chart types that mislead for this question) and `notes`. Draws on the practice described by Stephen Few (Show Me the Numbers) and Alberto Cairo (The Functional Art); the rankings are our own judgment, not a formula. Pure computation.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
chart_colour_checkCheck a set of chart series colors.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Check a set of chart series colors. Pass `colors` (list or comma-separated string of hex, rgb(), hsl() or CSS names, up to 24), `background` (default #ffffff) and `chartType` (bar, line, area, pie, scatter, map and so on). Returns: contrast of each color against the background with the 3:1 minimum for graphics (WCAG 2.x non-text contrast) and the nearest passing shade; pairwise color distance (CIE76 delta E) under typical vision, protanopia, deuteranopia, tritanopia (Machado et al. 2009 model) and grayscale, flagging pairs below 10 for filled marks or 15 for thin marks (working conventions, not standards); duplicate colors; a count warning past seven categorical hues; and a direct-labeling recommendation when there are more than four series. Also lists which colors of the Wong palette (Bang Wong, Points of view: Color blindness, Nature Methods, 2011) stay at 3:1 on your background. Pure computation.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
chart_lintLint a chart specification for graphical integrity, in the tradition of Edward Tufte (The Visual Display of Quantitative Information) and Alberto Cairo (How Charts Lie).No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Lint a chart specification for graphical integrity, in the tradition of Edward Tufte (The Visual Display of Quantitative Information) and Alberto Cairo (How Charts Lie). Pass `spec` as a JSON object or JSON string with: type (bar, column, line, area, pie, donut, scatter, bubble), title, source, units, labels (categories), series (list of {name, values, axis?}), axis {min, max, label}, axis2 {min, max} or dualAxis, threeD, stacked, sizeEncoding (area, radius, diameter, width, volume), decoration (list or object naming gradient, shadow, pattern, texture, heavyGridlines, border, backgroundImage, pictograph, ornament), valuesArePercent. Checks: clipped data, non-zero bar or area baselines with the lie factor (size of the effect shown in the graphic divided by the size of the effect in the data) computed from your first series, zoomed line axes, size encodings that scale by radius or volume (with the drawn ratio worked out), 3D, decoration that lowers the data-ink ratio, pies with more than about five slices or negative values, stacked or multi-line overload, dual axes, and a missing title, source or units. Each finding has an id, severity (error, warn, info), plain explanation and the numbers behind it. Pure computation: nothing is stored or logged.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
check_cjk_line_breakingStatic review of line-breaking and typography settings where CJK or Thai text appears.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Static review of line-breaking and typography settings where CJK or Thai text appears. Pass `source` as HTML with styles, or CSS plus sample text. Detects Han, kana, Hangul and Thai in the content, then flags word-break: break-all and keep-all used on the wrong script, missing lang (which selects glyph variants and break rules), <br> inside CJK paragraphs, spaces between CJK characters, widths set in ch, line-height under 1.5, letter-spacing, italics, nowrap, and lines starting with closing punctuation. Mentions line-break strict and loose and phrase-aware breaking where relevant. Reads the pasted source only; nothing is rendered or run, stored or logged. Wrapping happens in the browser, so check in a real one with a native reader.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
check_colour_modeCheck colors for print.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Check colors for print. Pass `colors` as lines: hex (#1a2b3c), rgb(26,43,60), cmyk(60,40,40,100) or C=60 M=40 Y=40 K=100, or a spot name (Pantone, HKS, RAL and so on). Optionally `stock` (coated, uncoated, newsprint) for the total area coverage (TAC, sum of the four ink percentages) limit, and `smallest_text_pt` for the smallest black text. Reports the mode of each line, naive CMYK for RGB (no color management), TAC against the limit (conventions: about 300 coated, 260 uncoated, 240 newsprint; the printer's figure wins), rich black versus flat K, 400% registration black, near-pure-RGB colors likely to fall outside the CMYK gamut, spot colors that add a plate, and overprint notes.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
check_contrastCheck color contrast.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Check color contrast. Give fg and bg, or pairs (a list of {fg, bg, label, sizePx, bold}), or a palette. Returns the WCAG 2.2 ratio with AA and AAA results for the text size, APCA Lc with what it is enough for, the nearest passing color, and for palettes the color pairs that become indistinguishable under protanopia, deuteranopia or tritanopia. Accepts hex, rgb(), hsl() and CSS names.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
check_contrast_tokensTake a design token file (CSS custom properties like --color-text: #111;, a JSON object of colors, or W3C design tokens) and test every foreground-like token against every backgrou…No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Take a design token file (CSS custom properties like --color-text: #111;, a JSON object of colors, or W3C design tokens) and test every foreground-like token against every background-like token for 4.5:1 text and 3:1 component contrast, with the nearest passing color, and find colors that merge under color blindness. Free up to about 30 colors; Pro takes 200. Returns a markdown report.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
check_design_driftCompare design tokens from the design tool with what the code uses.1 finding
Why it is in this group
- The description's first verb is "compare": a word for reading.
- The input takes a statement or command to run (input.code), which can change anything it can reach.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Findings
- Warn
The server marks "check_design_drift" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The description's first verb is "compare": a word for reading.
Description, as the server wrote it Compare design tokens from the design tool with what the code uses. Pass `design` (W3C design tokens JSON, Tokens Studio JSON, flat key/value JSON, or CSS variables) and `code` (CSS, SCSS or a Tailwind theme with custom properties or hex values). Both are parsed forgivingly. Returns findings grouped by severity with a count summary: design tokens missing from code, code tokens missing from design, same name with a different value (color distance in deltaE, px and rem normalized at 16px), different names with identical values (rename candidates), near-duplicate colors inside the code (deltaE under 2), hard-coded values in code that equal a token exactly, and values that are close to but not exactly a token, naming the token. No AI, nothing stored.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
check_email_accessibilityCheck an email for accessibility basics.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Check an email for accessibility basics. Pass `html`. Reports: missing lang and title, layout tables without role="presentation", images with no alt or throwaway alt (image, photo, a file name), very long alt text, links with vague wording (click here, read more, here), links with underline removed and no other cue, heading structure (none, or skipped levels), color contrast of text and background set on the same element (WCAG 1.4.3, 4.5:1), small text, all-caps blocks, and text locked inside images. Static checks only; it does not replace a screen reader pass. Email client support notes are from our own testing notes dated 2026-10 and may have drifted. Confirm in real clients (Litmus, Email on Acid, or seed accounts) before sending.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
check_email_dark_modeCheck how an email will fare in dark mode.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Check how an email will fare in dark mode. Pass `html`. Reports whether it declares color-scheme (meta and CSS), has a prefers-color-scheme: dark block, uses Outlook.com's [data-ogsc]/[data-ogsb] hooks, hard-codes white or near-white backgrounds, pairs colors that already have low contrast, uses mid-tone text colors that tend to fail after forced inversion, relies on background images, and has images likely to need a transparent or outlined version. Clients behave in three ways (leave as is, partly invert, fully invert); our notes describe them, and they drift. Email client support notes are from our own testing notes dated 2026-10 and may have drifted. Confirm in real clients (Litmus, Email on Acid, or seed accounts) before sending.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
check_email_preheaderCheck a preheader (the preview text after the subject in the inbox).No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Check a preheader (the preview text after the subject in the inbox). Pass `html` (the email; the first hidden block at the top of the body is read) or `preheader` text directly, and optionally `subject`. Checks: missing preheader, length (under about 40 characters lets the client pull in body text; over about 110 to 140 gets cut, both estimates and client dependent), repeating the subject, filler such as 'View in browser', padding characters to push body text out, and whether the hiding method is sound. Email client support notes are from our own testing notes dated 2026-10 and may have drifted. Confirm in real clients (Litmus, Email on Acid, or seed accounts) before sending.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
check_email_subjectCheck an email subject line.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Check an email subject line. Pass `subject`. Reports length in characters (phones show roughly the first 30 to 45; desktop 55 to 70, estimates), word count, spam-trigger words from a short list of about 35 phrases (filters weigh many signals, so a hit is a nudge, not a verdict), ALL CAPS, repeated punctuation, dollar signs and percent claims, emoji count, fake Re:/Fwd:, leading or trailing spaces, and personalisation placeholders (found, missing fallback, unbalanced braces, empty tags, leftover undefined/null/NaN).
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
check_font_coverageMaps text to scripts using a built-in Unicode block table (Latin including Vietnamese, Greek, Cyrillic, Hebrew, Arabic, Indic scripts, Thai, Lao, Khmer, Myanmar, Georgian, Armenian…No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Maps text to scripts using a built-in Unicode block table (Latin including Vietnamese, Greek, Cyrillic, Hebrew, Arabic, Indic scripts, Thai, Lao, Khmer, Myanmar, Georgian, Armenian, Ethiopic, Hangul, kana, Han, symbols, emoji). Pass `text` and optionally `fonts` as a comma-separated family list. Returns blocks present with counts and sample characters, the scripts needed, which listed families are known to cover each (from a small table of common fonts, with Noto per-script families recognized), gaps with a suggested Noto family, and notes on Han unification and RTL. Font coverage is from general knowledge of common fonts and varies by version and OS, so confirm in the font file; unknown fonts are reported as unknown. Nothing is rendered.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
check_formCheck a form's markup against the style rules in Luke Wroblewski's Web Form Design.Reads text others writeCan send data outNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Description, as the server wrote it Check a form's markup against the style rules in Luke Wroblewski's Web Form Design. Pass a public `url` (fetched safely, public hosts only) or pasted `html`. Reports findings with severity (high, medium, low, info) and a fix for label association and placement, placeholder used as a label, required and optional marking, number of fields, input types and autocomplete tokens, inline validation hooks (native constraints, aria-describedby, aria-invalid), vague or risky buttons (Submit, Reset, disabled submit), and ungrouped radio, checkbox and payment fields. Where a check is a common convention and not his stated rule, the finding says so. Reads static markup only: it cannot see CSS, so top versus left label alignment is not confirmed, and script-built fields are invisible. For WCAG-referenced form findings and error message linting, use audit_form.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
check_handoff_specChecks a design handoff list for gaps.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Checks a design handoff list for gaps. Pass `spec` as JSON (an array of {name, states, sizes, tokens, behaviours, notes, redlines}) or as lines such as `Button | states: default, hover | sizes: 40px | tokens: color.brand.500 | behavior: truncates`. The component type is inferred from the name (button, input, checkbox, toggle, select, link, tab, modal, tooltip, list or table, card, avatar, navigation) and compared with the states usually needed for that type, plus sizes (including WCAG 2.5.8 target size), token categories (color, spacing, type, radius), and behaviors (keyboard, long text, resize, empty, loading, error, focus, focus trap, motion timing). Lists redlines worth requesting. The expected sets are conventions. It sees only what you paste, not the design file.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
check_input_modalityStatic scan against WCAG 2.5.1 Pointer Gestures, 2.5.2 Pointer Cancellation, 2.5.3 Label in Name, 2.5.4 Motion Actuation, 2.5.7 Dragging Movements, 2.5.8 Target Size (Minimum), 2.1…No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Static scan against WCAG 2.5.1 Pointer Gestures, 2.5.2 Pointer Cancellation, 2.5.3 Label in Name, 2.5.4 Motion Actuation, 2.5.7 Dragging Movements, 2.5.8 Target Size (Minimum), 2.1.1 Keyboard and 1.4.13 Content on Hover or Focus. Pass `source` as HTML, CSS and any script you want covered. It finds :hover reveals with no focus twin, mouseover without focus, title-only names, draggable items and drag libraries, touchmove, swipe and pinch handlers, mousedown or touchstart actions, devicemotion, aria-label that does not contain the visible text, controls declared under 24 CSS px, and click handlers on non-interactive elements. Reads the pasted source only; nothing is rendered or run, stored or logged. Listeners added by bundled libraries are invisible unless named.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
check_keyboard_shortcutsChecks a shortcut map.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Checks a shortcut map. Pass `shortcuts`, one per line in the form `Cmd+K: Open search` (Mod, Cmd, Ctrl, Alt, Option, Shift and symbols like the command key are understood), and optionally `platform`: any (default), mac or windows. Flags duplicates within your list, collisions with common browser, text-editing and OS shortcuts, Ctrl+Alt combinations that equal AltGr on Windows or the VoiceOver modifier on Mac, screen reader keys, and single-character shortcuts under WCAG 2.1.4 Character Key Shortcuts (turn off, remap, or active only on focus). The built-in table is a convention-level summary of defaults, not exhaustive. No rendering, nothing stored.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
check_motionStatic motion audit against WCAG 2.2 (2.2.2 Pause, Stop, Hide; 2.3.1 Three Flashes; 2.3.3 Animation from Interactions).Reads text others writeCan send data outNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Description, as the server wrote it Static motion audit against WCAG 2.2 (2.2.2 Pause, Stop, Hide; 2.3.1 Three Flashes; 2.3.3 Animation from Interactions). Pass `html` and/or `css`, or a public `url` (the page and up to 4 same-site stylesheets are fetched). Flags autoplay video and audio, marquee and blink, infinite animations with no pause control, animation patterns that could flash (it cannot measure flash rate), parallax and scroll-linked motion, large translate or scale transitions, smooth scrolling, and durations over 400ms. Reports whether prefers-reduced-motion is honored (counts animations and transitions against reduced-motion rules) and returns a ready-to-paste reduced-motion CSS block. Each finding names its criterion, severity and fix. Reads source only; does not render the page or run script.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
check_name_fieldsReviews the name inputs in form markup and nearby script.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Reviews the name inputs in form markup and nearby script. Pass `markup` (HTML, optionally with script). Detects first, last, full, middle and title or gender fields from name, id, placeholder and label, then flags a first and last pair with no single-name option, maxlength under 50, minlength over 1, patterns and regexes that allow only A to Z, required middle name or title, split-on-space logic, and missing autocomplete tokens (WCAG 1.3.5). Guidance follows W3C internationalisation material on personal names, applied as convention. Server rules and database columns are not visible. Reads the pasted source only; nothing is rendered or run, stored or logged.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
check_naming_conventionsAudits names.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Audits names. Pass `names`, one per line; use slashes for paths or two-space indentation for nesting. Classifies each segment as kebab, snake, camel, Pascal, upper snake, title words or lower words and reports the dominant style and strays, then flags default tool names (Frame 12, Group 4, Rectangle), draft or version markers (final, copy, new, v2), names that repeat or differ only by case or separator, stray whitespace, emoji and file-unsafe characters, names over 40 characters, depth beyond 5 levels, mixed path separators and inconsistent state casing. It flags inconsistency, not which style is right. Works on the pasted names only.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
check_reading_orderStatic check for WCAG 1.3.2 Meaningful Sequence and 2.4.3 Focus Order.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Static check for WCAG 1.3.2 Meaningful Sequence and 2.4.3 Focus Order. Pass `source` as HTML with style blocks and inline styles, or as bare CSS. Flags CSS order, row-reverse and column-reverse, grid-auto-flow: dense, explicit grid placement, absolute and fixed positioning, right floats, positive tabindex, a footer before main in the DOM and skipped heading levels. Returns the DOM sequence of landmarks and headings so you can compare it with the visual order. Reads the pasted source only; nothing is rendered or run, stored or logged. It does not compute layout, so media-query rules are flattened and selectors are not matched to elements.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
check_reflowStatic reflow audit against WCAG 1.4.4 Resize Text, 1.4.10 Reflow, 1.4.12 Text Spacing, 1.3.4 Orientation and 1.4.13 Content on Hover or Focus.Reads text others writeCan send data outNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Description, as the server wrote it Static reflow audit against WCAG 1.4.4 Resize Text, 1.4.10 Reflow, 1.4.12 Text Spacing, 1.3.4 Orientation and 1.4.13 Content on Hover or Focus. Pass `html` and/or `css`, or a public `url` (the page and up to 4 same-site stylesheets are fetched). Flags viewport meta that blocks zoom, fixed pixel widths and min-widths over 320px, overflow hidden with fixed heights, px base font sizes, vw font sizes without clamp, !important on line-height, letter-spacing or word-spacing, orientation locks, nowrap text, tables without a scroll wrapper, hover-only reveals, and pages with no width media queries. Each finding names the criterion and gives the fix. Reads source only: it does not lay the page out or run script, so confirm at 320px width and 400 percent zoom.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
check_rtl_readinessStatic review for right-to-left languages.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Static review for right-to-left languages. Pass `source` as HTML with styles, or CSS. Lists margin, padding, border, left, right, float, clear, text-align, border-radius corner and translateX declarations with the logical replacement (margin-inline-start, inset-inline-end, text-align: start and so on), flags letter-spacing and italic on Arabic, justified Arabic, bidi overrides and embedded control characters, missing html lang and dir, free-text inputs without dir="auto", phone-like strings that need <bdi>, and directional icons by name (arrows, chevrons, back, next, reply, send) that usually mirror versus ones that do not (play, search, check, logos). Icon advice is by name and follows common guidance, so treat it as convention. Reads the pasted source only; nothing is rendered or run, stored or logged.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
check_state_coverageCheck interaction states in a stylesheet.Reads text others writeCan send data outNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Description, as the server wrote it Check interaction states in a stylesheet. Pass `css` (free) or a public `url` (Pro). Finds links, buttons, inputs, selects, summaries and classes that look interactive (btn, link, tab, toggle, switch, checkbox, chip, dropdown, form-control and others) or that already have a hover or focus rule, then lists for each which of :hover, :focus-visible (or :focus), :active, :disabled and aria or checked states have styles. A missing focus-visible style is high severity; a global :focus-visible rule counts for everything. Flags every rule that sets outline to none or 0 where no :focus or :focus-visible rule for the same element draws a ring, shadow or border instead (the :focus:not(:focus-visible) pattern is allowed).
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
check_svg_bloatStatic bloat review for one SVG.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Static bloat review for one SVG. Pass `svg`. Flags XML prolog and DOCTYPE, comments, editor markers (Inkscape, Sodipodi, Sketch, Illustrator, Figma, default Layer ids), generator notes used as title, path numbers with more than 3 decimals (with the characters that rounding to 2 or 3 would remove), hidden elements, empty and attribute-less wrapper groups, unreferenced ids, unused clip paths, masks, gradients and filters, attributes at default values, embedded base64 bitmaps, live text, matrix transforms, a missing viewBox, and script or external references. This tool does not rewrite or optimize the SVG and does not claim output; the byte estimate counts characters that the listed items occupy. Use SVGO or similar and compare the render.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
check_touch_targetsCheck target sizes and spacing against WCAG 2.2 SC 2.5.8 (24 by 24 CSS px, or a smaller target with enough spacing), the 44px guidance for iOS and the web, and 48dp for Android.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Check target sizes and spacing against WCAG 2.2 SC 2.5.8 (24 by 24 CSS px, or a smaller target with enough spacing), the 44px guidance for iOS and the web, and 48dp for Android. Pass targets as a list of {name, width, height, gap, inline} or text lines like 'Save button 40x32 gap=8'. Returns pass or fail per guideline with advice.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
cognitive_load_checkStatic audit of how much a screen asks of a person.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Static audit of how much a screen asks of a person. Pass `content` as HTML (best) or plain text. Reports interactive controls per screen, words, sentence length, an English reading-ease estimate, long paragraphs, missing headings, and form length, then checks WCAG 2.2 criteria that matter for cognition: 2.2.1 Timing Adjustable (meta refresh, countdown and session language), 3.3.8 Accessible Authentication Minimum (paste or autofill blocked, CAPTCHA or puzzle language), 3.3.7 Redundant Entry (confirm fields), 3.3.2 Labels or Instructions (placeholder-only fields, unexplained required fields), 1.3.5 Identify Input Purpose (missing autocomplete tokens) and 3.2.2 On Input. Count and length thresholds are conventions and are labeled so. Reads the pasted source only; nothing is rendered or run, stored or logged.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
color_meaning_checkCheck status or state colors for color-vision problems.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Check status or state colors for color-vision problems. Pass `states` as lines or comma-separated entries such as `error: #d32f2f, success: #2e7d32`, or an array of {label, color}. Labels like error, success, warning and info (and close variants) get matching icon and text suggestions; any other label gets generic ones. Every pair is compared by CIE76 deltaE under normal vision and simulated protanopia, deuteranopia and tritanopia (Machado et al. 2009, full severity). Under 10 counts as merged and under 20 as weak, both working conventions. Returns each pair's numbers, the worst case, a lightness gap, and a second cue per state with a reminder of WCAG 1.4.1 (Use of Color) and 1.4.11 (non-text contrast for the icon). Simulation covers dichromacy only; milder anomalous trichromacy falls between.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
colour_palette_brief_checkCheck a color palette against a brief.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Check a color palette against a brief. Give `palette` (hex, rgb() or hsl(), optionally named, up to 16) and optionally `brief` (words such as calm, energetic, premium, playful, trustworthy, natural, minimal, warm, cool). Returns measured properties, a verdict per brief word (supported, contradicted or untestable) with the measurement behind it, palette issues (too many colors, no neutral, near-duplicates, pairs that look alike under color-vision deficiency, no 4.5:1 text pair), and each color's contrast on white and black. Mood associations are common conventions and vary by culture.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
content_hierarchy_checkCheck inverted-pyramid structure and heading usefulness.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Check inverted-pyramid structure and heading usefulness. Give `text` (markdown-style # headings or 'h2:' prefixes), optionally `keyTerms` (what the reader must see early) and `firstWords` (default 40). Reports where each key term first appears and flags any after the first N words (if no key terms are given, the most repeated words are used and said so); lists the headings alone as the scan test; flags generic headings (Overview, Details), one-word or very long headings, skipped levels, duplicate headings, headings whose words never appear in their text, sections over 160 words, long first paragraphs and sentences, and openings that start with preamble. Position and pattern checks; it cannot judge whether the opening is the right content.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
convert_paper_sizeConvert paper sizes.1 finding
Why it is in this group
- The name "convert_paper_size" says "convert": a word for a change.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Findings
- Warn
The server marks "convert_paper_size" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The name "convert_paper_size" says "convert": a word for a change.
Description, as the server wrote it Convert paper sizes. Pass `size` by name (A0 to A10, B0 to B10, C0 to C10, Letter, Legal, Tabloid, Ledger, Executive, Statement, Junior Legal, ANSI C/D/E, Arch A to E, DL, US and EU business cards) or pass custom `width` and `height` with `unit` (mm, cm, in, pt). Returns millimeters, inches, points (1/72 in), pixels at 72, 96 and 300 ppi, aspect ratio, area, the nearest standard sizes with the difference, and the ISO relationships (A series halves the long side; B is the geometric mean of A neighbors; C is the geometric mean of A and B). ISO values are the published whole-millimeter figures.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
css_contrast_pairsExtracts real foreground and background color pairs from CSS instead of guessing roles from token names.Reads text others writeCan send data outNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Description, as the server wrote it Extracts real foreground and background color pairs from CSS instead of guessing roles from token names. Pass a public `url` (the page, its style blocks and up to 12 linked stylesheets are fetched) or paste `css` (and optionally `html` for its style blocks). For every rule that sets `color`, it finds the background set by the same rule, by an ancestor named in the selector, or by body/html, resolves var() custom properties, light-dark() and prefers-color-scheme / [data-theme] / .dark variants, and applies opacity. Returns WCAG ratio, APCA Lc, the threshold (large text 3, otherwise 4.5), file and line for each failing pair, a list of thin margins, a list of pairs whose background is assumed (only the page root or the browser default was available), and text over images or gradients that cannot be computed. Optional `scheme` (both, light, dark) and `viewport` (width in px for min-width/max-width media queries, default 1280). Reads CSS only: no rendering, inline style attributes, script, or text over photographs.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
css_to_dtcgConvert CSS custom properties into W3C design tokens (DTCG) JSON.1 finding
Why it is in this group
- The description's first verb is "convert": a word for a change.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Findings
- Warn
The server marks "css_to_dtcg" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The description's first verb is "convert": a word for a change.
Description, as the server wrote it Convert CSS custom properties into W3C design tokens (DTCG) JSON. Pass `css` (a :root block, a whole stylesheet, or a Tailwind v4 @theme block). Each variable is typed from its value and name (color, dimension in px or rem, duration, number, fontFamily, fontWeight, cubicBezier, shadow), grouped by type (color, spacing, radius, font-size, duration, and so on), and a var(--other) value becomes a {group.name} alias. The original CSS name and any dark value (from prefers-color-scheme: dark or a .dark or data-theme=dark selector) are kept in $extensions so dtcg_to_css can round-trip them. Variables that cannot be typed (calc(), clamp(), percentages, gradients, compound values, references to undefined variables) are listed with the reason instead of being guessed.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
dark_mode_paletteDerive a dark counterpart from light-mode tokens.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Derive a dark counterpart from light-mode tokens. Pass `tokens` as `name: color` lines (CSS custom properties work), a JSON object of name to color, or an array of {name, color}. Roles are guessed from the name (surface, raised surface, text, border, accent, on-accent) and then from the color. Surfaces are rebuilt around OKLCH L 0.19 with raised layers stepped lighter; text is mapped to light values under pure white; borders keep their distance from the surface; accents keep hue, gain lightness and lose about 15 percent chroma. Text and accents are nudged until they reach 4.5:1 on the lightest dark surface. Returns the mapping per token with a note, any pairs that still fail with their ratios, and CSS variables. The lifted-surface approach is a convention, not a standard.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
data_table_vs_chartDecide whether data belongs in a table, small multiples, a sparkline or a chart.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Decide whether data belongs in a table, small multiples, a sparkline or a chart. Pass `rows`, `cols` (numeric columns or series), `purpose` (lookup, compare, pattern, monitor), `precision` (exact or approximate), `space` (inline, tiny, normal, large), `timeSeries` (boolean), `mixedUnits` (boolean), `groups` (how many comparable series or panels could be drawn) and optionally `audience` (general, analyst, executive). Returns `recommendation`, `alternatives`, `reasons` and `cautions`. The logic follows the table-versus-graph reasoning in Stephen Few (Show Me the Numbers) and Edward Tufte's small multiples and sparklines, but the rules and the wording are our own. Pure computation.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
detect_design_slopLook for the default AI-generated design look in a live page's markup and CSS: purple-to-blue gradients, gradient text, a default font stack, pill buttons with arrows, uppercase ey…Reads text others writeCan send data outNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Description, as the server wrote it Look for the default AI-generated design look in a live page's markup and CSS: purple-to-blue gradients, gradient text, a default font stack, pill buttons with arrows, uppercase eyebrow labels, emoji headings, glassmorphism, glow blobs, equal card grids, stock marketing phrases and placeholder copy. Returns weighted signals and a 0 to 100 score. Signals, not proof.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
doctorDiagnose setup problems.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Diagnose setup problems. Reports what the server sees about this connection (client, whether a Pro key was received and is active, plan), checks a Figma link for the right shape (frame link with node-id, not a prototype or Community page), and matches a described symptom to fixes for: connected but nothing happens, local versus remote servers, 401 and 403, rate limits, tools or skills not triggering, and Figma selection problems. Does not use up a daily call.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
draft_brand_checklistProduce a deterministic brand guideline skeleton.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Produce a deterministic brand guideline skeleton. Pass `name` (required), and optionally `audience`, `tone` (words, comma separated or a list) and `constraints` (a list or lines such as "must meet WCAG AA" or "no stock photography"). Returns thirteen sections (purpose, audience, voice, logo, color, typography, layout and shape, imagery, iconography, motion, accessibility, channels, governance). Each lists what you already decided, the decisions still open and blank lines to fill in. Tone words are matched to a fixed table of design levers (type, color, shape, motion, voice) and pairs that pull against each other are named; words not in the table are listed as needing a definition. Constraints are sorted into accessibility, legal, existing assets, channels, language, budget and exclusions and shown in the sections they affect. Nothing is generated beyond these templates, so the same input always gives the same output.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
dtcg_to_cssConvert W3C design tokens (DTCG) JSON into code.1 finding
Why it is in this group
- The description's first verb is "convert": a word for a change.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Findings
- Warn
The server marks "dtcg_to_css" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The description's first verb is "convert": a word for a change.
Description, as the server wrote it Convert W3C design tokens (DTCG) JSON into code. Pass `tokens` (JSON text or object) and optionally `format` (css, tailwind or both; default both) and `prefix` (added to every CSS name). Reads $type and $value with group-level $type inheritance, {alias} references (kept as var() references in CSS, resolved for Tailwind), color as a string or color object, dimension and duration as strings or {value, unit}, fontFamily, fontWeight, number, cubicBezier, shadow (one layer or several), border, transition and typography (expanded to one variable per field). Also reads the older value and type keys. Names come from the path (color.brand.500 becomes --color-brand-500) unless the token carries a name from css_to_dtcg. Validation reports missing types, circular or dangling aliases, name collisions and every token that has no CSS form (gradients, strokeStyle objects, unknown types) with the reason.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
error_message_checkChecks UI and error strings against WCAG 3.3.1 (Error Identification), 3.3.3 (Error Suggestion), 4.1.3 (status messages that vanish) and plain-language convention.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Checks UI and error strings against WCAG 3.3.1 (Error Identification), 3.3.3 (Error Suggestion), 4.1.3 (status messages that vanish) and plain-language convention. Pass `messages`: a list of strings, or objects `{ text, where, autoDismissMs }` where `where` is inline, toast, tooltip, placeholder and so on. Flags: says what went wrong but not what to do next, states a rule without an action, blames the person, is a code or generic phrase only, contains system jargon, is shouted, runs long, or disappears (toast, tooltip, placeholder, auto-dismiss under 20 seconds). For each message that needs work it returns a fill-in template (problem, then one step) chosen by the kind of error, with the slots named. It does not write the final copy. Judges wording by pattern; it cannot see whether a message is linked to its field or announced.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
error_state_writer_templateAssemble error message skeletons.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Assemble error message skeletons. Give `problem` (what happened, required), and optionally `cause`, `fix` (the next step), `where` (field or page), `severity` (blocking, recoverable, warning), `dataSaved` (yes if the user's work is safe), `canRetry` and `contact`. Returns three layouts (inline under a field, banner or toast, full-page with title, body and buttons) built from your wording with square-bracket placeholders where you gave nothing, plus flags: blame words (invalid, wrong, you failed), technical codes, cute openers, missing next step, fix not starting with a verb, length limits, missing way to reach a person on blocking errors. It does not write the copy for you.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
extract_design_tokensExtract the design tokens a stylesheet actually uses.Reads text others writeCan send data outNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Description, as the server wrote it Extract the design tokens a stylesheet actually uses. Pass `css` (free) or a public `url` (Pro; every linked and inline stylesheet is read). Returns colors (hex, with alpha kept, grouped as text, background, border), font families, font sizes, weights, line heights, spacing from margin, padding and gap, radii, shadows, z-index values, media-query breakpoints, and transition durations and easings, each with a use count and where it was used. Custom properties are resolved through var() chains, with light and dark values side by side and unused variables listed. Output includes a W3C design tokens (DTCG) tree of the custom properties and a markdown summary. Reads CSS text only: styles injected by JavaScript, computed styles and inline style attributes are not seen.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
generate_conformance_reportPro.Reads text others writeCan send data out1 finding
Why it is in this group
- The name "generate_conformance_report" says "generate": a word for a change.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a URL (input.urls): a request to a URL can carry data to whoever runs it.
Findings
- Warn
The server marks "generate_conformance_report" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":true}; The name "generate_conformance_report" says "generate": a word for a change.
Description, as the server wrote it Pro. Fetch up to 10 public pages, run the static accessibility audit on each, and return a draft Accessibility Conformance Report in the shape of the ITI VPAT 2.5 WCAG edition: a report header (product, version, date, evaluation methods, contact, notes), then a table of every WCAG 2.2 Level A and AA success criterion (55, including 2.4.11, 2.5.7, 2.5.8, 3.2.6, 3.3.7 and 3.3.8; 4.1.1 Parsing is omitted because it is obsolete in 2.2). Each row has a Conformance Level of exactly Supports, Partially Supports, Does Not Support, Not Applicable or Not Evaluated, plus remarks. Rows are marked Does Not Support or Partially Supports only where the audit found a real issue, citing the page and the count. Rows that do not apply (no media, no forms, no drag or gesture code) are Not Applicable and state what was searched. Rows only a person can judge (keyboard use, focus order, captions quality, images of text) are Not Evaluated with a two-step test. Supports is used where the HTML, stylesheets and same-site scripts show no failure, and the remark states what was and was not checked. The report carries a disclaimer that it is a draft from automated checks and not a legal conformance claim, and a Manual testing still needed section. Pass `urls` (array, up to 10) or one `url`; productName, version, vendor, contactEmail and evaluator are optional header fields. Returns an object with `report` (markdown), `criteria` ([{criterion, name, level, remarks}]), `pages` and `counts`. Do not present the output to a customer as a finished VPAT.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
heuristic_worksheetBuild a Nielsen ten-heuristics review worksheet for a screen or flow.Reads text others writeCan send data outNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Description, as the server wrote it Build a Nielsen ten-heuristics review worksheet for a screen or flow. Give text (the copy of the flow), html or a url. Returns, for each heuristic, keyword and markup signals found or missing, review prompts, and blanks for findings and 0 to 4 severity. The signals point at where to look; a human evaluation is still required.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
inventory_componentsInventory the components in a stylesheet and, if given, its markup.Reads text others writeCan send data outNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Description, as the server wrote it Inventory the components in a stylesheet and, if given, its markup. Pass `css` and optionally `html` (free), or a public `url` (Pro, which also reads the page markup). Classes are grouped into roles (button, card, input, badge, nav, alert, modal, avatar, tooltip) from their names, then variants are found from modifier classes (btn--primary, btn-lg, btn.primary). Reports each component family with its base properties and variants, inconsistencies across the same role (different corner radius, padding, font size, weight or height between families, or between variants that should match; size and shape variants are allowed to differ), naming collisions (btn and button both defined, for example) and properties set twice at the same level. With markup it also counts instances, common class combinations, inner structures, classes used but never styled and unclassed native buttons.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
label_clarity_checkCheck navigation or category labels.1 finding
Why it is in this group
- The name "label_clarity_check" says "label": a word for a change.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Findings
- Warn
The server marks "label_clarity_check" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The name "label_clarity_check" says "label": a word for a change.
Description, as the server wrote it Check navigation or category labels. Give `labels` (one per line or comma separated). Flags catch-alls (Resources, Solutions, Misc), labels over 4 words, 'X and Y' labels, instruction words, all capitals, trailing punctuation, filler suffixes (hub, center, zone), duplicates and one-letter-apart near-duplicates, groups of labels with overlapping scope from a built-in set (support/help/contact, news/blog/press, products/solutions/services and others), mixed verb-led and noun labels, and mixed Title Case and sentence case. Wording checks only; test labels with people.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
lint_brand_voiceCheck text against brand voice rules.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Check text against brand voice rules. Give text and rules (a string of plain lines, or a JSON object, or an array). Understood rules: banned words or phrases, preferred terms ('use sign in not log in', or 'log in -> sign in'), required capitalisation of product names, sentence case or title case for headings (markdown # lines or heading: prefixes), a maximum sentence length in words, banned punctuation (exclamation marks, em-dashes, ellipses, emoji, ampersands, all caps), required terms, and tone words to avoid ('tone to avoid: salesy'). Rules are parsed forgivingly and echoed back so a misread rule can be corrected. Returns violations with line number, offending text, the rule and a suggested replacement, plus the rules that never matched anything.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
lint_design_feedbackLint design critique.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Lint design critique. Sorts each note into observation, opinion, solution-without-problem, vague, or question, explains what is missing, and gives an observation, impact, suggestion skeleton for weak notes. Reports the share of notes ready to act on.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
lint_design_mdScore a DESIGN.md (the brand and design context file models read before building): missing sections, no hex values, text and background pairs that fail contrast, too many typefaces…No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Score a DESIGN.md (the brand and design context file models read before building): missing sections, no hex values, text and background pairs that fail contrast, too many typefaces, adjectives a model reads as the generic look, no never-list, no sizes, too long or too thin.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
lint_disclosure_copyLint financial, legal and consent copy (fees, rates, terms, privacy notices, error and decline messages) for plain language.1 finding
Why it is in this group
- The name "lint_disclosure_copy" says "copy": a word for a change.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Findings
- Warn
The server marks "lint_disclosure_copy" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The name "lint_disclosure_copy" says "copy": a word for a change.
Description, as the server wrote it Lint financial, legal and consent copy (fees, rates, terms, privacy notices, error and decline messages) for plain language. Give text and optionally kind (fee, rate, terms, consent, privacy, error, marketing). Returns Flesch Reading Ease and Flesch-Kincaid grade (target grade 8 or lower), average sentence length, long words, passive voice, stacked negatives, legalese and jargon with plain replacements, vague money wording ('up to', 'as low as', 'may apply', 'certain fees') with why regulators dislike it, key terms buried after the first 150 characters or in long sentences, a per-kind checklist of missing elements, and draft rewrites for the worst sentences. A writing check, not legal or compliance advice.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
lint_email_htmlLint pasted email HTML.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Lint pasted email HTML. Checks: size against the roughly 102 KB point where Gmail clips a message, doctype, charset, viewport and lang, layout built on divs, flexbox, grid, float or positioning instead of tables (Outlook for Windows renders with the Word engine and ignores much modern CSS), background shorthand and background images (need VML and a color fallback for Outlook), CSS variables, calc, rem/vw units, web fonts without fallback, <style> reliance without inline styles, container width (about 600 to 640 px is the convention), images without alt, width or display:block, image-only mail that goes blank when images are blocked, hidden preheader, color-scheme meta, small tap targets on button-like links, missing or odd unsubscribe link, JavaScript and forms, empty or http links. Email client support notes are from our own testing notes dated 2026-10 and may have drifted. Confirm in real clients (Litmus, Email on Acid, or seed accounts) before sending.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
lint_lottie_jsonLint a Lottie (Bodymovin) animation.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Lint a Lottie (Bodymovin) animation. Pass `json` as the text of the .json file. Checks: valid JSON with the expected top-level fields (v, fr, ip, op, w, h, layers), text size (over about 100 KB is heavy for UI, over 500 KB is very heavy; conventions), layer count including pre-compositions, expressions (unsupported on several native players), embedded base64 images, masks, mattes, blend modes, 3D layers, text layers and effects (patchily supported on mobile players), frame rate (above 60 is wasted; above 30 rarely needed for UI), duration, and canvas size. dotLottie (.lottie zip) files are not supported; unzip first.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
lint_research_questionsLint user research questions, one per line, for leading wording, double-barrelled questions, hypotheticals, predictions, loaded words, jargon, closed questions in an open interview…No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Lint user research questions, one per line, for leading wording, double-barrelled questions, hypotheticals, predictions, loaded words, jargon, closed questions in an open interview, why-questions and unlabeled rating scales, with a suggested rewrite for each problem.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
lint_token_namesLint design token names from a list, CSS variables or a JSON token file: mixed separators, colors named by hue where roles belong, values or locations in names, version words, dupl…No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Lint design token names from a list, CSS variables or a JSON token file: mixed separators, colors named by hue where roles belong, values or locations in names, version words, duplicate values, abbreviation drift (bg and background) and irregular scales.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
lint_tracking_planLint a product analytics tracking plan (event names with optional properties, one per line like 'project_created (template, source)') for mixed naming styles, vague events, UI-elem…No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Lint a product analytics tracking plan (event names with optional properties, one per line like 'project_created (template, source)') for mixed naming styles, vague events, UI-element names, near-duplicate events, tense and order drift, and personal data in property names. With no events and a productType (saas, ecommerce, marketplace, content, mobile) it drafts a starter plan.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
localisation_readinessCheck source strings for translation readiness.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Check source strings for translation readiness. Give `strings` (one per line, optionally 'key = text' and a trailing '[max 20]' limit), optionally `languages`, `maxChars` (a limit for every string) and `expansion` (your own factors, e.g. 'de=1.3, fr=1.25'; if omitted a default planning table of our own rough factors is used and named in the output). Projects length per language (short strings grow more), flags overflow against limits, and flags: fragments glued together, unnamed multiple placeholders, '(s)' plurals and counted nouns without a plural rule, 'a/an' before a placeholder, hard-coded dates, times, ordinals, currency and number separators, gendered pairs, left/right words, idioms, Latin abbreviations, markup, emoji and all-capital text. Pattern checks on English; character counts are not pixel widths.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
logo_contrast_variantsPick logo colorways per background.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Pick logo colorways per background. Give `colours` (brand palette: hex, rgb() or hsl(), optionally named, e.g. 'Ink #14213d, Paper #fff8ec, Flame #fca311'; first is the primary), optionally `logo` (the colors inside the full-color logo, default the primary only) and `backgrounds` (default: each brand color plus white and black). For each background it reports whether the full-color logo reaches 3:1, and if not, which one-color version (a brand color, then white, then black) reaches 4.5:1 or at least 3:1, with ratios. Also suggests the set of colorways to produce.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
logo_size_rulesCompute logo clear space and minimum sizes.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Compute logo clear space and minimum sizes. Give width and height (any unit, pass `unit`), optionally `letterform` (height of a capital or the x-height in the same unit), `kind` (wordmark, lockup, symbol, monogram) and `clearSpaceMultiple` (default 1 letterform). Returns clear space on each side, the total exclusion zone, a compact clear space (half), minimum height and width for screen (smallest letterform 8 px) and print (1.5 mm), and a size table for common widths marking where the logo falls below the minimum. If `letterform` is omitted it is estimated and the result says so. The floors are conventions; your brand guide may differ.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
measure_leadingCheck line length and suggest leading.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Check line length and suggest leading. Pass `fontSizePx` and `containerPx` (the text column width in px). Optional: `charsPerLine` (use a counted value instead of the estimate), `language` (en, de, fr, es, it, pt, nl, ru, ja, zh, ko; sets the average character width), `avgCharWidthEm` (override, default 0.5). Returns the measure in characters, whether it is inside 45 to 75 (25 to 40 for CJK), a recommended line-height (about 1.4 at the short end rising to 1.6 at the long end, tighter for large type), paragraph spacing, and the container width that hits the range. The 45 to 75 range is Bringhurst's guidance (The Elements of Typographic Style) as cited in Smashing's Typography Best Practices; 1.4 to 1.6 line spacing is from UXPin's Principles of Visual Consistency. The leading curve is a convention. Width is an estimate from an average character, so it is a guide, not a measurement.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
modular_scaleBuild a modular type scale.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Build a modular type scale. Pass `base` (px, default 16) and `ratio` (a number from 1.01 to 4, or a name: minor second, major second, minor third, major third, perfect fourth, augmented fourth, perfect fifth, golden, major sixth, octave; default major third 1.25). Optional: `stepsUp` (default 6), `stepsDown` (default 2), `rootPx` (default 16), `minViewport` and `maxViewport` (defaults 320 and 1280), `minBase` and `minRatio` for the small-screen end of the fluid scale (default: same base, ratio pulled 20 percent toward 1). Returns each step with px, rem and a clamp() expression that interpolates linearly between the two viewports, plus fixed and fluid CSS custom properties. The ratio names come from music intervals and are a web design convention, not a law; Bringhurst, The Elements of Typographic Style, discusses scales of related sizes. Pure calculation, nothing is stored.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
naming_checkScreen brand name candidates.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Screen brand name candidates. Give `names` (1 to 30) and optionally `existing` (names to compare against: competitors, your own brands) and `tld` (default com). For each name: letters, syllables, length note, pronunciation or typing hazards (silent letters, consonant stacks, digits, symbols, accents, camel case), spelling-ambiguity patterns with a low, medium or high risk of being misspelled after being heard, a domain-friendly form (availability is NOT checked), and close matches by edit distance, simple sound-key and containment against `existing` and the other candidates. This is a language and usability screen only: it makes no trademark, legal or availability claims and does not check meaning in other languages.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
notification_copy_checkCheck notification copy.Can send data out1 finding
Why it is in this group
- The name "notification_copy_check" says "copy": a word for a change.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- outboundThe input takes a destination (input.channel): what the tool writes goes there.
Findings
- Warn
The server marks "notification_copy_check" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The name "notification_copy_check" says "copy": a word for a change.
Description, as the server wrote it Check notification copy. Give `notifications`, one per line as 'title | body' with an optional channel prefix (push:, email:, inapp:, sms:), and `channel` for the default (push). For email, title is the subject and body the preheader; for sms the whole line is the message. Flags: missing title or body, length beyond approximate truncation (push 45/110, email 50/100, in-app 60/140, SMS 160) with a preview of what stays visible, generic text, urgency language, all capitals, exclamation marks, emoji, no specific name, number or time, greeting openers, label prefixes, title repeating body. Truncation varies by device; the numbers are approximate.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
number_format_checkAudit how numbers are displayed.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Audit how numbers are displayed. Pass `numbers` (the strings exactly as shown, as a list or newline or comma-separated text; JSON numbers lose their formatting so strings are better), `context` (axis, tooltip, table cell, headline), and optionally `locale` (en-US, de-DE, fr-FR and so on), `raw` (the unrounded values in the same order, to test whether rounding creates ties or reverses the ranking) and `total` (a stated total to compare with the displayed parts). Checks: consistent decimal places, mixed thousands or decimal separators, the ambiguity of a lone separator before three digits (1,000 versus 1.000), missing grouping on long numbers, mixed k, M, B suffixes and the lowercase m trap, mixed or repeated units and currency, negative-number styles, right-alignment and tabular figures for table cells, uneven axis ticks, false precision, and rounding that changes ranking or breaks a sum. Returns findings and, where the set is uniform enough, a suggested reformatting. Pure computation.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
page_weight_reportWeighs a public page from its delivered HTML.Reads text others writeCan send data outNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Description, as the server wrote it Weighs a public page from its delivered HTML. Pass `url`. Reports HTML bytes (uncompressed, plus the server's reported transfer length when given), element count, link count and distinct link targets, image count with lazy-loaded and no-dimension counts, iframes, media, inline style and script bytes, and the number and uncompressed size of linked stylesheets and scripts (up to 10 stylesheets and 20 subresources are fetched, each up to 3 MB). Warns on thousands of links, large HTML, large DOM, many images or scripts. Reads up to 5 MB of HTML; if it stops early it says so, states how many bytes it read and what share of the page that is when the size is known, and treats every count as a minimum. Does not run script, so content added at runtime, images, fonts and media sizes are not included.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
palette_harmonyBuild color harmonies from base colors.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Build color harmonies from base colors. Pass `colors` (one to six colors as hex, rgb(), hsl() or CSS names, comma or newline separated, or an array) and optionally `harmony` (complementary, analogous, triadic, split-complementary or tetradic) to return one scheme. Hue is rotated in OKLCH with lightness and chroma held, so the set is evenly weighted; colors that cannot hold the chroma inside sRGB are reduced and marked. Returns hex and oklch() for each color, a note on which harmony suits which job, and a list of near-duplicates (OKLab distance under 3, a working convention). Near-gray bases have no hue and are flagged. OKLCH opposites differ from the red-yellow-blue paint wheel. Pure maths, nothing stored.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
plain_language_checkCheck text for plain language.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Check text for plain language. Give `text`, optionally `targetGrade` (default 8) and `jargon` (your own words to flag). Returns Flesch Reading Ease, Flesch-Kincaid grade, rough reading age (grade plus 5), average sentence length, passive sentence count, sentences over 25 words, jargon and formal words with plain replacements (about 70 built in), wordy phrases ('in order to' -> 'to'), stacked negatives, and the worst sentences with reasons. English only; syllable counts are rule-based so grades are estimates.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
plan_asset_exportsBuilds an export plan.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Builds an export plan. Pass `assets` as lines like `search-icon | 24x24 | icon | web, ios, android` or as a JSON array of {name, width, height, kind, platforms}. Kinds: icon, logo, illustration, photo, ui, background, favicon, app-icon, og-image, sprite. For each asset returns the recommended format (SVG for vector kinds, AVIF or WebP with JPEG fallback for photos, PNG for flat UI), web 1x to 3x sizes, iOS @2x and @3x, Android mdpi to xxxhdpi sizes (1, 1.5, 2, 3, 4 times), favicon and PWA sizes, adaptive icon geometry, the 1200x630 social card, and warnings for fractional or odd sizes. Rules of thumb that change over time; confirm against current platform docs. Computes sizes only and produces no files.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
plan_breakpointsPlan responsive breakpoints from content.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Plan responsive breakpoints from content. Pass `contentWidths` (list of px widths where your layout starts to fail or needs to change, found by dragging the browser or frame), and optionally `deviceTargets` (px widths of devices you must support; these are checked against the result, never used to create breakpoints), `minMeasure` (default 45 characters) and `maxMeasure` (default 75) for text columns, `fontSize` (default 16), `gutter` (default 24), `margin` (default 24), `maxColumns` (default 3), and `fluidMin` and `fluidMax` (viewport range for the fluid rules, default 320 and 1440). Returns breakpoints (your content widths plus widths derived from how many columns at the minimum measure fit, and where one column reaches the maximum measure), a container max-width for each, ready CSS, fluid clamp() rules for body size, h1, gutter and page padding computed so they hit exact minimum and maximum at the range ends, a note for any two breakpoints within 10% of each other, and for each device target whether it is already near a breakpoint. Sources: Marcotte, Responsive Web Design (breakpoints follow the design). The 45 to 75 character measure, the 0.5em average character width and the 10% closeness test are conventions. Pure arithmetic, nothing stored.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
plan_critiquePlan a design critique for a stage (concept, wireframe, visual, prototype, build, shipped): a framing statement, timed agenda, the questions that fit the stage, roles, and the kind…No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Plan a design critique for a stage (concept, wireframe, visual, prototype, build, shipped): a framing statement, timed agenda, the questions that fit the stage, roles, and the kinds of feedback to turn away until a later stage.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
plan_durationsPlan animation durations.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Plan animation durations. Pass `distance_px` (how far the thing moves, 0 to 5000), `size` (small, medium, large, fullscreen), `complexity` (simple, moderate, complex) and optionally `kind` (enter, exit, state-change) and `allow_long` (true to lift the 400 ms UI cap for decorative or page-level motion). Returns a recommended duration, the enter and exit pair, a five-step token scale and the rationale. The formula is our own heuristic (stated in the output), shaped by common practice; it is an estimate to tune by eye, not a standard.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
plan_focus_orderModels sequential keyboard navigation for WCAG 2.4.3 Focus Order, 2.1.1 Keyboard, 2.4.1 Bypass Blocks, 2.4.7 Focus Visible and 4.1.2 Name, Role, Value.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Models sequential keyboard navigation for WCAG 2.4.3 Focus Order, 2.1.1 Keyboard, 2.4.1 Bypass Blocks, 2.4.7 Focus Visible and 4.1.2 Name, Role, Value. Pass `markup` (HTML with optional style blocks). Returns the numbered Tab sequence with guessed accessible names (aria-label, label, text, alt, title), the elements left out (hidden, inert, tabindex -1), and findings: positive tabindex, focusable elements inside aria-hidden, onclick on non-interactive elements, controls with no name, no skip link, outline: none without a replacement, and dialogs that need manual testing. It is a model of the browser rule from attributes, not a recording; Reads the pasted source only; nothing is rendered or run, stored or logged.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
plan_impositionPlan imposition for a booklet or book.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Plan imposition for a booklet or book. Pass `pages` (1 to 1024) and `binding`: saddle (stitched; one nested stack, pages in multiples of 4), perfect or sewn (gathered signatures of `signature` pages: 4, 8, 16, 32 or 64; 16 is the common offset size). Returns pages after padding to the next multiple, blank pages to add, number of signatures or sheets, and for saddle the printer-spread pairs for every sheet (outer and inner sides). With `caliper_microns` it estimates creep for saddle stitch: the sheet nested k sheets inside the outermost shifts its content outward by about k x caliper, so planned inward compensation for the outermost sheet is about (sheets - 1) x caliper. Printers use their own creep tables, and some compensate with 2 x caliper; treat this as an estimate.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
plan_responsive_imagesPlans responsive images.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Plans responsive images. Pass `breakpoints` as min-viewport:width pairs such as `0:100vw, 768:50vw, 1200:600px` (vw or px), and optionally `dprs` (default 1,2), `sourceWidth` (original pixel width, upscaled candidates are dropped), `format` (jpeg, webp, avif, png; default webp), `aspect` (16:9 or 1.5, adds a height for layout stability), `urlPattern` containing {w}, `aboveFold` (true adds fetchpriority high and no lazy loading), `maxViewport` (default 1920) and `content` (photo, graphic or noisy). Returns the srcset widths (thinned so neighbors differ by at least 18 percent, max 8), the sizes string, an <img> tag, and a rough byte estimate from typical bits per pixel for the format. Estimates are within about 2x either way. It plans markup; it does not resize files.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
plan_staggerPlan staggered reveals.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Plan staggered reveals. Pass `count` (1 to 200), `duration_ms` (each item's own duration, default 300), `pattern` (linear, ease-out, ease-in, center-out, edge-in, scattered), optional `step_ms` (gap between items) and `budget_ms` (cap on the whole sequence, default 600, a convention). Returns the delay for every item, total time, the step actually used, a CSS custom-property snippet for linear patterns, and warnings (a step under one frame at 60 Hz is invisible; very long lists should animate in groups).
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
plan_text_expansionPlans for translation growth.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Plans for translation growth. Pass `strings` (one UI string per line), optionally `languages` (two-letter codes from de, fr, es, pt, it, nl, ru, pl, fi, tr, vi, id, ar, he, hi, th, ja, ko, zh; default de, fr, es, ru, fi, ja, ar) and `maxChars` (the character capacity of your container). For each string returns the planned character range per language and the worst case, and flags strings that exceed maxChars. Short strings expand proportionally more than long ones, so the table applies a length boost. Factors are rule-of-thumb ranges for ordinary UI copy (convention), not measurements; CJK shrinks in characters but can grow in width and height. Run real translations before locking a layout.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
plan_usability_testBuild a usability test plan skeleton with fixed template logic (no model call).No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Build a usability test plan skeleton with fixed template logic (no model call). Pass `goal` (what you need to learn), `participants` (a number, a list of criteria, or {count, groups, profile}) and `tasks` (strings, or {name, scenario, start, success}). Optional: `product`, `method` (moderated or unmoderated), `session_minutes`. Returns a screener built from your criteria, a session outline, each task checked for leading wording (naming buttons or menus, 'click', 'easily') with a scenario shape, start point, success and stop rules, metrics (completion, time, errors, Single Ease Question, problem log), a sample-size note that explains the five-user model (1 - (1 - L)^n) and its limits, and a markdown note-taking sheet. Draws on general practice from Krug, Cooper's About Face and Norman. The leading-wording check is a keyword heuristic. The five-user figures are a convention from the usability literature, not verified against the design library.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
repeated_label_checkFinds repetition that makes a page harder to scan by ear.Reads text others writeCan send data out1 finding
Why it is in this group
- The name "repeated_label_check" says "label": a word for a change.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Findings
- Warn
The server marks "repeated_label_check" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":true}; The name "repeated_label_check" says "label": a word for a change.
Description, as the server wrote it Finds repetition that makes a page harder to scan by ear. Pass a public `url` or `html`. Reports: a heading and a link with the same text in the same region or close in reading order (for example a section heading and a "see all" link with the same words); duplicate heading text within a region; links with the same text going to different destinations; the same link repeated to one destination; multiple navigation, complementary, region or search landmarks without distinct names; more than one main, banner or contentinfo; and duplicate id values. Headings and links that are aria-hidden or hidden are skipped, because a browser leaves them out of the accessibility tree, and the count of skipped items is stated. Reads delivered markup only: CSS-hidden duplicates (desktop and mobile navs), shadow DOM and script-built content are not handled.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
review_animation_principlesReview a described animation against the twelve animation principles (squash and stretch, anticipation, staging, pose to pose, follow through, slow in and slow out, arcs, secondary…No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Review a described animation against the twelve animation principles (squash and stretch, anticipation, staging, pose to pose, follow through, slow in and slow out, arcs, secondary action, timing, exaggeration, solid drawing, appeal). Pass `description` (what moves, how, how long, why) and optionally `purpose` (ui, marketing, illustration). Keyword-based: a principle marked 'not mentioned' may still be present in the design, and one marked 'mentioned' is not proof it is done well. Each principle comes with a question to answer and how it translates to interface motion. Also flags stated durations over 400 ms for UI.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
review_date_number_formatsReviews text for formats that do not travel across locales.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Reviews text for formats that do not travel across locales. Pass `text` and optionally `locales` (BCP 47 tags, comma-separated) and `currency` (ISO 4217 code, default USD). Flags numeric dates that could be day-first or month-first, English month-first dates, ordinals like 4th, mixed 12 and 24 hour clocks, comma versus period grouping used together, symbol before and after amounts, bare $ signs, percent spacing, imperial units, hard-coded plurals such as item(s) and 'x days ago', and US phone formats. Then prints a table of a fixed date, number and currency amount in each locale using the runtime's Intl data, so you can see what the same value looks like. English text patterns only; Intl output can vary a little by platform version.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
review_locale_pickerReviews a language or region switcher.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Reviews a language or region switcher. Pass `locales` as markup (a <select> with options, or a list of links with hreflang or lang) or as lines such as `de: Deutsch`. Flags flag emoji or flag imagery standing in for languages, options named in English instead of their own language (autonym), options shown only as a code, missing lang on options (WCAG 3.1.2 Language of Parts), invalid BCP 47 tags, labels that differ from the usual autonym in a built-in table of about 30 languages, RTL options without dir, duplicates, unsorted long lists, a select that navigates on change (WCAG 3.2.2 On Input), an unlabeled select (4.1.2), and language mixed with region. Static; it does not load the target pages.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
review_microcopyReview interface strings.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Review interface strings. Give `items`, one per line, each prefixed with its type: button:, link:, label:, tooltip:, empty:, confirmation:, placeholder:, heading:. Type-specific checks: buttons and links (starts with an action verb, generic labels like OK or Submit, 1 to 3 words, 'click' wording, link text out of context), labels (short, noun-like), tooltips (length, not repeating the control), empty states (says why and offers a next step), confirmations (names what happened or will happen, 'Are you sure?', yes/no buttons). All types: vague error wording, filler, 'please', interjections, technical codes, all capitals. Findings are rated high, medium or low. Pattern checks on single strings in English.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
review_ui_copyReview interface copy, one string per line, optionally prefixed with a type (button:, error:, empty:, tooltip:, placeholder:, heading:, toast:, label:).1 finding
Why it is in this group
- The name "review_ui_copy" says "copy": a word for a change.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Findings
- Warn
The server marks "review_ui_copy" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The name "review_ui_copy" says "copy": a word for a change.
Description, as the server wrote it Review interface copy, one string per line, optionally prefixed with a type (button:, error:, empty:, tooltip:, placeholder:, heading:, toast:, label:). Checks each string for what its type needs (errors say what to do, empty states give a next step, buttons name the outcome), checks the set for inconsistency, and runs AI-writing tells over everything.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
save_project_contextPro.1 finding
Why it is in this group
- The name "save_project_context" says "save": a word for a change.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Findings
- Warn
The server marks "save_project_context" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The name "save_project_context" says "save": a word for a change.
Description, as the server wrote it Pro. Save named project context (brand notes, a DESIGN.md, past decisions, personas) against the Pro key, up to 20 items of 50,000 characters, so later sessions and prompts can reuse it.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
scan_piiScan text for real personal and secret data that should not appear in design files, and return a masked report plus a redacted copy.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Scan text for real personal and secret data that should not appear in design files, and return a masked report plus a redacted copy. Pass `text` (for example every text layer from a Figma frame, a spec, mockup sample data or OCR text from a screenshot) and optionally `mode`: design (default) or strict, which also flags capitalised full names next to labels like Customer. Detects emails (example.com/org/net and test/invalid TLDs are treated as safe), phone numbers (fictional 555-01xx and Ofcom drama ranges are safe), payment cards checked with Luhn (public test cards such as 4242 4242 4242 4242 are safe), IBANs checked with mod-97, US SSNs (invalid ranges ignored), UK National Insurance numbers, IPv4 and IPv6 addresses outside documentation ranges, AWS, Stripe, GitHub, Slack, Google, Anthropic and OpenAI keys, JWTs and private key blocks, and lower-confidence street addresses and labeled dates of birth. Each finding has type, masked preview (never the full secret), line, confidence and a safe placeholder; `redacted` is the input with every finding replaced. The text is processed in memory, never stored or logged. Use it as the last step before sharing a file.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
score_design_systemScore a design system from its CSS.Reads text others writeCan send data outNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Description, as the server wrote it Score a design system from its CSS. Pass `css` and optionally `html` and `pairs` (free), or a public `url` (Pro). The score is out of 100 and weighted: tokens 25 (share of color, size, spacing, radius and shadow declarations that go through a variable, full marks at 60%, scaled down below 8 custom properties), scales 25 (mean of color, type, spacing and radius discipline), components 20 (penalty of 0.20, 0.10 and 0.03 per high, medium and low inconsistency), state coverage 20 (focus-visible weighted 0.5, hover 0.25, pressed and disabled less, minus 0.15 per outline removed without a replacement) and contrast 10 (share of text and background pairs reaching 4.5:1; pairs are taken from rules that set both colors, plus any you state as `pairs`, a list of {foreground, background, label} or lines such as "#767676 on #ffffff"). An area with nothing to measure is left out and the others are rescaled. The result shows each area's points, the basis, and a ranked fix list with the points each fix would recover.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
site_audit_summaryPro.Reads text others writeCan send data outNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Description, as the server wrote it Pro. Score a site in one call. Crawls the site from `url` (same origin only, up to 40 pages, 4 requests at a time, or only the `paths` you list), uses sitemap.xml to find pages, and obeys robots.txt for the user agent ATPDesigners. Reads static HTML only. The result opens with coverage: pages read of pages found, which were skipped or truncated, and requests used. Runs the inventory, meta, heading and link health checks over the same crawl and returns a 0 to 100 score per area (each check has a weight; points lost are weight times the share of pages or links affected; the formula is printed in the result), an overall average, and the top 10 issues. Optional `maxLinkChecks` lowers the link check cap.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
site_consistencyPro.Reads text others writeCan send data outNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Description, as the server wrote it Pro. Find templates that drift. Crawls the site from `url` (same origin only, up to 40 pages, 4 requests at a time, or only the `paths` you list), uses sitemap.xml to find pages, and obeys robots.txt for the user agent ATPDesigners. Reads static HTML only. The result opens with coverage: pages read of pages found, which were skipped or truncated, and requests used. Treats the most common version of each area as the baseline and lists the pages that differ: primary nav links, header and footer markup, footer links, stylesheet set, h1 class, button and link text written several ways, html lang and icons.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
site_heading_outlinePro.Reads text others writeCan send data outNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Description, as the server wrote it Pro. Check heading structure across a site. Crawls the site from `url` (same origin only, up to 40 pages, 4 requests at a time, or only the `paths` you list), uses sitemap.xml to find pages, and obeys robots.txt for the user agent ATPDesigners. Reads static HTML only. The result opens with coverage: pages read of pages found, which were skipped or truncated, and requests used. Returns each page's heading outline, pages with no h1 or more than one, skipped levels, empty headings, duplicate titles and h1s, and a site-wide table.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
site_inventoryPro.Reads text others writeCan send data outNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Description, as the server wrote it Pro. Map a site into page types. Crawls the site from `url` (same origin only, up to 40 pages, 4 requests at a time, or only the `paths` you list), uses sitemap.xml to find pages, and obeys robots.txt for the user agent ATPDesigners. Reads static HTML only. The result opens with coverage: pages read of pages found, which were skipped or truncated, and requests used. Returns page-type groups (by URL pattern and template markers) with counts found and read, depth, orphan hints from sitemap and link comparison, and a pages.md style table with one verified URL per type that other audits can take as input.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
site_link_healthPro.Reads text others writeCan send data out1 finding
Why it is in this group
- The name "site_link_health" says "link": a word for a change.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Findings
- Warn
The server marks "site_link_health" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":true}; The name "site_link_health" says "link": a word for a change.
Description, as the server wrote it Pro. Check the links on a site. Crawls the site from `url` (same origin only, up to 40 pages, 4 requests at a time, or only the `paths` you list), uses sitemap.xml to find pages, and obeys robots.txt for the user agent ATPDesigners. Reads static HTML only. The result opens with coverage: pages read of pages found, which were skipped or truncated, and requests used. Collects internal links from the pages read, requests up to 60 destinations not already crawled (HEAD first, GET if HEAD fails), and reports non-2xx results, redirects (final URL only; hop counts are not visible), links to http, links with no name, vague link text, one text pointing to different places, and links with no destination. Links with aria-hidden=true are not counted as unnamed. Optional `maxLinkChecks` lowers the check cap.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
site_meta_auditPro.Reads text others writeCan send data outNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Description, as the server wrote it Pro. Audit head metadata across a site. Crawls the site from `url` (same origin only, up to 40 pages, 4 requests at a time, or only the `paths` you list), uses sitemap.xml to find pages, and obeys robots.txt for the user agent ATPDesigners. Reads static HTML only. The result opens with coverage: pages read of pages found, which were skipped or truncated, and requests used. Checks title and description presence, length and duplicates, canonical links that point elsewhere, html lang, viewport, og and twitter tags, robots meta noindex, hreflang validity and icon links.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
site_performance_hintsPro.Reads text others writeCan send data outNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Description, as the server wrote it Pro. Spot static performance problems across a site. Crawls the site from `url` (same origin only, up to 40 pages, 4 requests at a time, or only the `paths` you list), uses sitemap.xml to find pages, and obeys robots.txt for the user agent ATPDesigners. Reads static HTML only. The result opens with coverage: pages read of pages found, which were skipped or truncated, and requests used. Reports HTML size, stylesheets and scripts that block rendering in the head, images without width and height or loading=lazy, inline @font-face without font-display, Google Fonts URLs without display, font preloads without crossorigin and third-party origins without preconnect. It never measures time and makes no speed claims; linked CSS and JS files are not fetched.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
sitemap_to_outlineConvert a sitemap into an outline.1 finding
Why it is in this group
- The description's first verb is "convert": a word for a change.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Findings
- Warn
The server marks "sitemap_to_outline" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The description's first verb is "convert": a word for a change.
Description, as the server wrote it Convert a sitemap into an outline. Give `input` as a list of URLs or paths (one per line; query strings and fragments are dropped) or an indented tree, and optionally `format` (numbered, markdown, indent). URL lists are folded into a tree under Home, with labels guessed from slugs (placeholders for real titles). Returns the outline plus notes: sections that exist only as parents of other URLs (no page of their own), ID segments that need names, depth over 4, a branch with more than 9 children, and single-child sections. Up to 2000 lines.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
stress_test_localisationStress-test UI strings for translation.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Stress-test UI strings for translation. Give strings (one per line, optionally 'text | maxChars' or 'label | text | maxChars', or a JSON array of {text, maxChars, label}), optional locales (default de, fr, es, fi, ru, ja, ar, zh) and optional defaultMaxChars. Applies the published IBM translation expansion guidance by string length (up to 10 chars about +200 to 300%, 11 to 20 about +80%, 21 to 30 about +60%, 31 to 50 about +40%, 51 to 70 and over 70 about +30%), adjusted per locale (CJK contracts to about half, German and Finnish run longer than French). Predicts expanded length, flags strings that overflow their limit, generates a pseudo-localised version, and flags concatenated fragments, variables that need ordering freedom, hard-coded dates, numbers, currency and plurals, text-in-image risks, and right-to-left mirroring notes. Estimates from published ratios, not translations.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
tagline_reviewReview taglines.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Review taglines. Give `taglines` (1 to 25, one per line), optionally `brand` (to flag repeating the name) and `cliches` (extra phrases to flag). Checks word and character count, about 90 stock phrases and fillers, abstract words, three-item lists, 'where X meets Y' constructions, exclamation marks, and concreteness (numbers or named things). Returns a 0 to 100 concreteness score per line, issues, and a flag when the line could be used by any competitor. A heuristic aid; it does not check uniqueness or legal status.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
tint_shade_scaleGenerate a 50, 100, 200 ...1 finding
Why it is in this group
- The description's first verb is "generate": a word for a change.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Findings
- Warn
The server marks "tint_shade_scale" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The description's first verb is "generate": a word for a change.
Description, as the server wrote it Generate a 50, 100, 200 ... 900, 950 scale from one `color` (hex, rgb(), hsl() or a CSS name) and optionally a `name` for the CSS variables. Your color is kept exactly on the step nearest its own lightness; other steps follow a fixed OKLCH lightness curve with the hue held and chroma tapering toward the ends (reduced where sRGB cannot hold it). Each step reports hex, oklch(), WCAG contrast against white and against black, and whether it passes 4.5:1 as text on each. Also returns the lightest step that passes as text on white, the lightest that passes as text on black, any step that passes both, and a CSS custom-property block. Contrast is WCAG 2.x relative luminance.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
touch_target_cssStatic estimate of the rendered size of interactive elements (a, button, input, select, textarea, summary, role=button/link, onclick) for WCAG 2.5.8 Target Size (Minimum, 24px) and…Reads text others writeCan send data outNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Description, as the server wrote it Static estimate of the rendered size of interactive elements (a, button, input, select, textarea, summary, role=button/link, onclick) for WCAG 2.5.8 Target Size (Minimum, 24px) and the 44px guidance. Pass `html` and `css`, or a public `url` (page plus up to 12 stylesheets). It matches CSS rules to elements, uses explicit width/height/min sizes, padding, border, line-height and font-size (with browser defaults for form controls), guesses text width, reads margins and gap including li > a wrappers, and decides whether a neighboring control exists. Output groups elements by kind with a status: fail-estimate, under-24-isolated, under-24-spaced, inline (exempt inside a sentence), unknown (icon-only with no stated size) or ok. Optional `viewport` (default 390) selects media queries. States plainly that it is an estimate and includes a Puppeteer snippet for the rendered measurement. It does not apply state, sibling or structural selectors, transforms, container queries or script-set sizes.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
trunk_testAnswer the six questions of Steve Krug's trunk test (Don't Make Me Think) from a page's markup: what site is this, what page am I on, what are the major sections, what are my optio…Reads text others writeCan send data outNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Description, as the server wrote it Answer the six questions of Steve Krug's trunk test (Don't Make Me Think) from a page's markup: what site is this, what page am I on, what are the major sections, what are my options at this level, where am I in the scheme of things, how can I search. Pass a public `url` (fetched safely, public hosts only) or `html`/`text` (pasted markup or page text). Looks at the title tag, site name meta, header logo and home link, h1, nav landmarks, breadcrumb markup and BreadcrumbList data, aria-current and active classes, and search forms. Each question comes back answerable, partial or missing with the evidence found. Reads static markup only: it cannot see layout, prominence, script-built menus or how the page looks at arm's length, so it supports the real paper test and does not replace it.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
type_crimes_lintLint text, HTML or CSS for common typographic errors.1 finding
Why it is in this group
- The name "type_crimes_lint" says "type": a word for a change.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Findings
- Warn
The server marks "type_crimes_lint" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The name "type_crimes_lint" says "type": a word for a change.
Description, as the server wrote it Lint text, HTML or CSS for common typographic errors. Pass `text` (plain copy, an HTML fragment or a stylesheet) and optionally `kind`: auto (default), text, html or css. Checks: two spaces after a period, repeated spaces, straight double quotes and apostrophes where curly belong, hyphen or double hyphen used as a dash, hyphen in a numeric range (use an en dash, no spaces), spaced en dash in a range, three periods for an ellipsis, spaced-out lowercase, all-caps runs, widow hints, synthesised or fake small caps, letterspaced lowercase, capitals without tracking, uppercase body text, body line-height under 1.2, justified text without hyphens, four or more typefaces, bold or italic with no font files or font-synthesis setting, and no text-wrap rule. Each finding has rule, severity (high, medium, low), line, excerpt, message, fix and basis (the book it traces to, or convention). Sources: Lupton, Thinking with Type (sentence spacing, quotes, dashes); Bringhurst, The Elements of Typographic Style; Smashing eBooks, Typography Best Practices (small caps, faux styles, justification, widows). Thresholds such as the 1.2 line-height floor and the typeface count are conventions. Static checks only; code and pre blocks are skipped.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
type_pairing_checkCheck a font pairing against a built-in table of about 55 common families (Helvetica, Arial, Inter, Roboto, Open Sans, Lato, Georgia, Times New Roman, Garamond, Caslon, Jenson, Pal…1 finding
Why it is in this group
- The name "type_pairing_check" says "type": a word for a change.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Findings
- Warn
The server marks "type_pairing_check" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The name "type_pairing_check" says "type": a word for a change.
Description, as the server wrote it Check a font pairing against a built-in table of about 55 common families (Helvetica, Arial, Inter, Roboto, Open Sans, Lato, Georgia, Times New Roman, Garamond, Caslon, Jenson, Palatino, Baskerville, Playfair Display, Bodoni, Trade Gothic, Futura, Knockout, Champion Gothic, Oswald, Courier New, JetBrains Mono and others, plus common aliases). Pass `fonts`: two or three names, optionally with a role as "Name:role" (heading, body, code, ui, display, caption; default order is heading, body, code). Returns each face's class (serif, sans, mono, display, script) and structure, how the pair contrasts (same class and structure reads as too similar, serif with sans as clear contrast), x-height and width warnings, role problems (display face for body, high-contrast face at text size, monospace prose), and a verdict: works, works with adjustments, risky or incomplete. A family not in the table is reported as unknown with no verdict for it. Table values are qualitative and approximate. Ideas: Lupton, Thinking with Type (contrast of structure when combining faces); Cullen, Layout Workbook (compare x-height and cap height); Smashing eBooks, Typography Best Practices (short x-height at small sizes).
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
url_structure_reviewReview pasted URLs or paths (no fetching).Can send data outNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- outboundThe input takes a URL (input.urls): a request to a URL can carry data to whoever runs it.
Description, as the server wrote it Review pasted URLs or paths (no fetching). Give `urls`, one per line, up to 500. Reports trailing slash mix, capital letters (paths are case-sensitive on many servers), mixed word separators (hyphen, underscore, camelCase), run-together words, file extensions, opaque ID segments, query parameters, session IDs, encoded characters, double slashes, depth (more than 4 segments), segments over 40 characters, years in paths, www/non-www and http/https mixing, URLs that differ only by case, slash or separator, singular/plural twins of one section, and an overall percentage of readable segments. Pattern checks on the strings only; it cannot see redirects.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
usability_statsUsability arithmetic with formulas shown.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Usability arithmetic with formulas shown. mode sus: score System Usability Scale responses (rows of ten 1-5 answers) with grade, percentile and 95% interval. mode discovery: participants needed to find a share of problems (Nielsen and Landauer). mode ab: sample size per variant for a conversion test (baseline, lift in percent, optional dailyVisitors). mode survey: responses needed for a margin of error.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
vertical_rhythmSnap a type scale to a baseline grid.No findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Description, as the server wrote it Snap a type scale to a baseline grid. Pass `baseline` (px, default 8) and `sizes`: an array of pixel sizes, or "name:size" strings such as "h1:48" and "body:16". Optional: `bodySize` (default 16) and `rootPx` (default 16). Returns, per size, a line-height rounded to a whole number of baseline units (never under 1.1 times the size), margin-block start and end in baseline multiples, and CSS using calc(var(--baseline) * n). Preferred ratios fall as size rises (1.5 up to 18px, 1.35 up to 28px, 1.25 up to 40px, then 1.15); that curve and the margin pattern are conventions, with body leading in line with UXPin's 1.4 to 1.6 and vertical rhythm as a composition aid per Smashing's Typography Best Practices. Aligns line boxes and margins; it does not read font metrics.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
write_design_changelogBuilds a changelog from two lists.1 finding
Why it is in this group
- The name "write_design_changelog" says "write": a word for a change.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
Findings
- Warn
The server marks "write_design_changelog" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The name "write_design_changelog" says "write": a word for a change.
Description, as the server wrote it Builds a changelog from two lists. Pass `before` and `after` as lines (`name: value` or just `name`) or JSON (flat or nested objects, W3C-style tokens with $value, or arrays of names). Returns added items grouped by prefix, changed values phrased with the real change (color from-to, pixel difference), probable renames guessed from similar names or identical values (confirm each), removed items, counts, and a suggested semantic-version bump (removals and renames suggest major, additions minor, value changes patch; a convention). Optional `version` and `title` head the output. It compares only the text you give it and cannot see visual changes that are not in the lists.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
Only reads 16Show 16 read-only tools
alt_text_qualityReads alt text on a page.Reads text others writeCan send data outNo findings
Why it is in this group
- The description's first verb is "read": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- untrusted-inputThe input takes a URL (input.url), and the tool reads it: it reads web pages, which anyone can write.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Claude Code: ask, because it is tagged outbound.
Description, as the server wrote it Reads alt text on a page. Pass a public `url` or `html`. Counts every img element (not a sample) and states how many it read and how many it skipped as aria-hidden or presentational. Flags missing alt, file names and camera names (IMG_1234, Name_With_Underscores.jpg), alt equal to the file stem, placeholder words, "image of" openers, fallback patterns such as "Title, picture", duplicate alt text across different images, alts over 150 characters, and empty alt inside a link that has no other text. Also checks og:image:alt and twitter:image:alt (missing, empty, or poor). Tells you if the page was cut off. Reads delivered markup only: script-added images, CSS backgrounds and inline SVG are not seen, and it cannot judge whether a clean description is accurate.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
analyse_card_sortAnalyze an open card sort (method after Donna Spencer, Card Sorting).No findings
Why it is in this group
- The name "analyse_card_sort" says "analyse": a word for reading.
Description, as the server wrote it Analyze an open card sort (method after Donna Spencer, Card Sorting). Pass `participants`: an array with one entry per person, each a map of group name to a list of cards (or {id, groups: {...}}). Accepts 3 to 60 participants and 5 to 100 distinct cards. Returns a similarity matrix (percent of participants who grouped each pair), agreement per card pair, suggested categories from average-linkage hierarchical clustering cut at `threshold` percent agreement (default 50), cards with low agreement, and a table of the group labels people used with how many used each. Card names match case-insensitively; labels match on letters and digits only, so synonyms stay separate. Fewer than about 15 participants triggers a caution. It does not explain why people grouped cards, so follow up with interviews.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
check_proximity_alignmentFind layout slips that read as mistakes.No findings
Why it is in this group
- The description's first verb is "find": a word for reading.
Description, as the server wrote it Find layout slips that read as mistakes. Pass `boxes` (array or JSON string of {x, y, w, h, label}, 2 to 400 boxes) or `html` plus optional `css`. For markup, geometry comes from data-x, data-y, data-w, data-h attributes or from left, top, width and height in px (inline style, or simple .class, #id and tag rules in `css`); elements without all four are skipped and counted. Nothing is rendered, so this reads declared numbers only. Reports (1) near-misses: left, right, top, bottom or center lines of two boxes that differ by more than 0.01px and no more than `tolerance` (default 6px), with both values and the difference; (2) inconsistent gaps between three or more siblings that share a row or column, listing every gap and the most common one; (3) orphans, boxes that line up with nothing and sit more than twice the median nearest-neighbor distance away. Sources: Müller-Brockmann, Grid Systems in Graphic Design (alignment to a shared structure); Lupton, Thinking with Type (alignment and grouping); Wroblewski, Web Form Design (labels close to their fields). The tolerance and orphan thresholds are conventions. Pure arithmetic, nothing stored.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
colour_temperature_mixRead a palette's balance.No findings
Why it is in this group
- The description's first verb is "read": a word for reading.
Description, as the server wrote it Read a palette's balance. Pass `colors` (two to sixty) as hex, rgb(), hsl() or CSS names, optionally each followed by its area share, such as `#1b3a5c 55%, #f2efe6 30%, #e4572e 10%`, or an array of strings or {color, share}. Returns warm, cool, neutral and in-between share, a chroma-weighted warm/cool index, chroma spread, lightness range and darkest-to-lightest contrast, and the dominant, accent and neutral colors. With shares for every color it also reports whether the split sits near 60-30-10 (read as 50-70, 20-40 and 5-20, our own tolerance); without shares it says the split cannot be read. Temperature bands are OKLCH hue conventions (warm 350 to 115, cool 180 to 285, neutral chroma under 0.03). Sources: Hughes, Graphic Design: Learn It, Do It; Wroblewski, Site-Seeing.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
compare_token_setsCompare two versions of a design system.Reads text others writeNo findings
Why it is in this group
- The name "compare_token_sets" says "compare": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Compare two versions of a design system. Pass `before` and `after` (each CSS with custom properties, W3C design tokens JSON, or a flat key/value JSON object; free) or `before_url` and `after_url` (Pro). Tokens are matched by name. Reports added, removed, renamed (same value under a new name) and changed tokens, and gives an overall class. Breaking: a token removed or renamed, a type change, a color that moved by deltaE 25 or more, or a size that changed by half or more. Minor: a new token, a visible color shift (deltaE 2 to 25) or size change. Patch: a color change under deltaE 2 or a size nudge of 1px or less. When a side defines no custom properties, the two are compared by the values they use and the class is minor if 15% or more of the values churned, otherwise patch. This is different from check_design_drift, which compares a design file with code at one point in time.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
design_easingDescribe an easing and get CSS back.No findings
Why it is in this group
- The description's first verb is "describe": a word for reading.
Description, as the server wrote it Describe an easing and get CSS back. Pass `easing` as a name (ease, ease-out, ease-out-cubic, ease-in-out-quart, ease-out-back and others), as `cubic-bezier(x1,y1,x2,y2)` (x values must sit between 0 and 1), or as `spring` with optional `mass`, `stiffness`, `damping`. Optional `duration_ms` (bezier only; a spring has its own settle time). Returns the CSS timing function, a CSS `linear()` version, 11 sampled points of progress against time, overshoot and settle figures for springs, and notes on feel with a convention for when to use it. The named curve values are widely shared conventions, not a standard beyond the five CSS keywords.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
get_project_contextPro.No findings
Why it is in this group
- The name "get_project_context" says "get": a word for reading.
Description, as the server wrote it Pro. List the saved project context, or read one item by name.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
getting_startedExplain what this server can do and suggest the three best first tasks for what the person has (a Figma link, a live URL, copy, a research plan, an event list).No findings
Why it is in this group
- The description's first verb is "explain": a word for reading.
Description, as the server wrote it Explain what this server can do and suggest the three best first tasks for what the person has (a Figma link, a live URL, copy, a research plan, an event list). Use this first when the person is new or unsure what to ask for.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
print_file_checklistGet a prepress checklist tailored to the job.Reads private dataNo findings
Why it is in this group
- The description's first verb is "get": a word for reading.
What it can reach
- private-dataThe name "print_file_checklist" says "file": it reads files.
Description, as the server wrote it Get a prepress checklist tailored to the job. Pass `product` (flyer, brochure, book-perfect, book-saddle, business-card, poster, packaging, large-format), `colour` (cmyk, cmyk-spot, black-white) and optionally `finishes` (comma-separated: spot-uv, foil, emboss, die-cut, varnish, lamination, perforation, fold). Returns grouped checks: document setup, color, images, type, finishing files, export and delivery, with the figures to confirm with your printer. Items are common practice; the printer's own spec sheet always wins.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
rendered_vs_static_notesLookup for the gap between what our static tools read and what a browser renders.Reads private dataReads text others writeNo findings
Why it is in this group
- The description's first verb is "lookup": a word for reading.
What it can reach
- private-dataThe name "rendered_vs_static_notes" says "note": it reads notes.
- untrusted-inputThe description's first sentence says "lookup" and "browser": it reads web pages, which anyone can write.
Description, as the server wrote it Lookup for the gap between what our static tools read and what a browser renders. Pass `finding`: a finding or tool name (for example "unnamed link", "alt text", "contrast", "touch targets", "duplicate landmark", "aria-hidden", "carousel") or a WCAG number. Returns when the static result over-reports, when it under-reports, how far to trust it, and a ready-to-run Puppeteer or DevTools snippet for the rendered check. With no `finding`, lists every id. Deterministic table; nothing is fetched or run.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
screen_reader_scriptRead HTML (pass `html`, or a public `url`) and return a linear approximation of what a screen reader announces, in document order: landmarks, headings with levels, links, buttons, …Reads private dataReads text others writeCan send data outNo findings
Why it is in this group
- The description's first verb is "read": a word for reading.
What it can reach
- private-dataThe description's first sentence says "read" and "document": it reads documents.
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- untrusted-inputThe description's first sentence says "read" and "html": it reads web pages, which anyone can write.
- untrusted-inputThe input takes a URL (input.url), and the tool reads it: it reads web pages, which anyone can write.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Claude Code: ask, because it is tagged outbound.
Description, as the server wrote it Read HTML (pass `html`, or a public `url`) and return a linear approximation of what a screen reader announces, in document order: landmarks, headings with levels, links, buttons, form controls with accessible names and states (required, expanded, checked, disabled and more), images with alt, lists and tables. Accessible names are computed in a simplified way (aria-labelledby, aria-label, label for or wrapping label, alt, title, text content); aria-hidden, hidden and inline display:none are honored. Problems are flagged inline: no accessible name, generic link text, duplicate landmark with no label, skipped heading level, name from placeholder only, missing alt, table without header cells. Output is capped at the first 250 nodes, with a count of those omitted. This is an approximation of the accessibility tree built from static markup, not a recording of NVDA, JAWS or VoiceOver; it does not run script or apply stylesheets. Returns an object with `report` (the script as text), `nodes` and counts.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
site_page_diffPro.Reads text others writeCan send data outNo findings
Why it is in this group
- The name "site_page_diff" says "diff": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- untrusted-inputThe input takes a URL (input.url), and the tool reads it: it reads web pages, which anyone can write.
- outboundThe input takes a URL (input.url): a request to a URL can carry data to whoever runs it.
Claude Code: ask, because it is tagged outbound.
Description, as the server wrote it Pro. Fetch two public pages (`url` and `compareUrl`, which must differ; use it for staging against production) and return a structural diff: metadata, landmarks, headings, links, images, stylesheets and scripts (same-host links compared by path), text length, and the change in static accessibility findings. Obeys robots.txt for the user agent ATPDesigners and opens with coverage.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: true
taxonomy_overlapFind overlaps in tags and categories.No findings
Why it is in this group
- The description's first verb is "find": a word for reading.
Description, as the server wrote it Find overlaps in tags and categories. Give `tags` and/or `categories` (or `terms`), one per line, optionally with usage counts as 'term (12)'. Groups terms that are the same once case, plurals and punctuation are ignored, same words in a different order, differing by spacing or hyphen, or one or two letters apart; says when a group spans both lists; suggests the most-used (else shortest) term to keep; lists possible parent and child pairs where one term's words are all inside another's; and lists terms used once or never when counts are given. Matching is by spelling, so true synonyms need a human.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
tree_test_scorerScore tree test (findability) data.No findings
Why it is in this group
- The name "tree_test_scorer" says "tree": a word for reading.
Description, as the server wrote it Score tree test (findability) data. Give `results` as CSV with a header row and one row per participant per task, with columns task, success (yes/no or 1/0), and optionally direct (reached the answer without backtracking), first_click (the top-level label clicked first), time (seconds). Optionally `expectedFirstClicks` as lines 'Task name = Label, Label'. Returns per task: participants, success rate with 95% Wilson interval and a band (80+ strong, 60 to 79 mixed, under 60 weak, our rule of thumb), directness, direct-success rate, first-click distribution and the share on expected labels, median time, and notes (small sample, success that needed backtracking, wrong first clicks). Reports skipped rows rather than failing.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
whoamiShow the caller's plan (Free or Pro) and how many calls remain today on each tool.No findings
Why it is in this group
- The name "whoami" says "whoami": a word for reading.
Description, as the server wrote it Show the caller's plan (Free or Pro) and how many calls remain today on each tool. Does not use up a daily call.
Annotations the server declares
- readOnlyHint: true
- destructiveHint: false
- openWorldHint: false
This is not a safety rating, and no finding is not a safety guarantee. The groups and findings come from fixed checks of the tool definitions the server returned on the date shown, not from its code or what it does when called. How the checks work.
Exfil surface
Which tools read private data, which read text someone else can write, and which can send data out. One of each is a path a prompt injection can use.
3468 paths in this server alone from private data, through text someone else wrote, to a way out. Denying 3 private-data tools breaks every one.
- Reads private data3
- Reads files, mail, messages, databases, secrets, calendars or repositories.
- Reads text others write34
- Brings in text someone else can write: web pages, inbound email, messages, issues and comments.
- Can send data out34
- Can carry data to people or systems: it sends, posts or publishes, or takes a recipient, channel or URL.
{
"permissions": {
"deny": [
"mcp__designers__print_file_checklist",
"mcp__designers__rendered_vs_static_notes",
"mcp__designers__screen_reader_script"
]
}
}Other servers in the same agent add their own tools to these paths. Audit your whole setup to see them together.
Remote posture
What anyone on the internet sees at the remote endpoint: an anonymous initialize and tools/list, and the public OAuth metadata.
Looked at Nov 20, 2026, 18:33 UTC, unchanged since Oct 29, 2026. No credentials were sent and no tool was called. What is looked at.
- Reachable
- yes
- HTTP status of an anonymous initialize
- 200
- tools/list served without credentials
- yes
- Tools that change things, listed without credentials
- 125
- Protocol version
- 2025-06-18
- WWW-Authenticate on 401
- not observed
- resource_metadata in WWW-Authenticate
- not observed
- RFC 9728 protected resource metadata
- not observed
- Authorization servers
- not observed
- Legacy HTTP+SSE transport
- no
- Dynamic client registration
- not observed
- Client ID metadata documents
- not observed
- HighThe whole server
The endpoint served tools/list without credentials, and the list has 125 tools that change things (1 destructive, 124 write). Whether a call also works without credentials was not tested: tools are never called.
What this check looks forMatched text
https://designers.allthepossibles.com/mcp: tools/list returned 141 tools to an anonymous client, including save_project_context (destructive), check_contrast (write), audit_page_accessibility (write), heuristic_worksheet (write), detect_design_slop (write) and 120 more
Posture changes
- Oct 29, 2026
- Tools that change things, listed without credentials: 18 to 125
Findings
Matches of fixed checks, with the text they matched.
- Warnreview_ui_copy
The server marks "review_ui_copy" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The name "review_ui_copy" says "copy": a word for a change.
The server marks "save_project_context" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The name "save_project_context" says "save": a word for a change.
The server marks "generate_conformance_report" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":true}; The name "generate_conformance_report" says "generate": a word for a change.
The server marks "lint_disclosure_copy" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The name "lint_disclosure_copy" says "copy": a word for a change.
The server marks "check_design_drift" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The description's first verb is "compare": a word for reading.
- Warntype_crimes_lint
The server marks "type_crimes_lint" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The name "type_crimes_lint" says "type": a word for a change.
Show 15 more findingsShow fewer
The server marks "type_pairing_check" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The name "type_pairing_check" says "type": a word for a change.
The server marks "build_spacing_scale" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The description's first verb is "generate": a word for a change.
- Warntint_shade_scale
The server marks "tint_shade_scale" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The description's first verb is "generate": a word for a change.
The server marks "repeated_label_check" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":true}; The name "repeated_label_check" says "label": a word for a change.
- Warnsite_link_health
The server marks "site_link_health" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":true}; The name "site_link_health" says "link": a word for a change.
- Warnaudit_type_scale
The server marks "audit_type_scale" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":true}; The name "audit_type_scale" says "type": a word for a change.
- Warndtcg_to_css
The server marks "dtcg_to_css" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The description's first verb is "convert": a word for a change.
- Warncss_to_dtcg
The server marks "css_to_dtcg" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The description's first verb is "convert": a word for a change.
The server marks "convert_paper_size" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The name "convert_paper_size" says "convert": a word for a change.
The server marks "button_label_consistency" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The name "button_label_consistency" says "label": a word for a change.
The server marks "notification_copy_check" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The name "notification_copy_check" says "copy": a word for a change.
The server marks "label_clarity_check" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The name "label_clarity_check" says "label": a word for a change.
The server marks "sitemap_to_outline" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The description's first verb is "convert": a word for a change.
- Warnaudit_icon_set
The server marks "audit_icon_set" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The name "audit_icon_set" says "set": a word for a change.
The server marks "write_design_changelog" read-only (readOnlyHint: true), and its own name, description or input give the class "write".
What this check looks forMatched text
annotations: {"readOnlyHint":true,"destructiveHint":false,"openWorldHint":false}; The name "write_design_changelog" says "write": a word for a change.
History
Changes to its tool definitions and to its remote endpoint, newest first.
Tools120 added, 5 changed.+120 added~5 changedView diff
- Added:alt_text_qualityOnly reads
- Added:analyse_card_sortOnly reads
- Added:approx_print_colourChanges things
- Added:audit_dark_patternsChanges things
- Added:audit_email_accessibilityChanges things
- Added:audit_formChanges things
- Added:audit_icon_setChanges things
- Added:audit_motion_cssChanges things
- Added:audit_spacingChanges things
- Added:audit_token_scalesChanges things
- Added:audit_type_scaleChanges things
- Added:brand_architecture_plannerChanges things
- Added:brand_voice_consistencyChanges things
- Added:build_gridChanges things
- Added:build_spacing_scaleChanges things
- Added:button_label_consistencyChanges things
- Added:calc_fitts_hickChanges things
- Added:calc_print_resolutionChanges things
- Added:calc_print_specChanges things
- Added:calculate_proportionChanges things
- Added:chart_chooserChanges things
- Added:chart_colour_checkChanges things
- Added:chart_lintChanges things
- Added:check_cjk_line_breakingChanges things
- Added:check_colour_modeChanges things
- Added:check_design_driftChanges things
- Added:check_email_accessibilityChanges things
- Added:check_email_dark_modeChanges things
- Added:check_email_preheaderChanges things
- Added:check_email_subjectChanges things
- Added:check_font_coverageChanges things
- Added:check_formChanges things
- Added:check_handoff_specChanges things
- Added:check_input_modalityChanges things
- Added:check_keyboard_shortcutsChanges things
- Added:check_motionChanges things
- Added:check_name_fieldsChanges things
- Added:check_naming_conventionsChanges things
- Added:check_proximity_alignmentOnly reads
- Added:check_reading_orderChanges things
- Added:check_reflowChanges things
- Added:check_rtl_readinessChanges things
- Added:check_state_coverageChanges things
- Added:check_svg_bloatChanges things
- Added:cognitive_load_checkChanges things
- Added:color_meaning_checkChanges things
- Added:colour_palette_brief_checkChanges things
- Added:colour_temperature_mixOnly reads
- Added:compare_token_setsOnly reads
- Added:content_hierarchy_checkChanges things
- Added:convert_paper_sizeChanges things
- Added:css_contrast_pairsChanges things
- Added:css_to_dtcgChanges things
- Added:dark_mode_paletteChanges things
- Added:data_table_vs_chartChanges things
- Added:design_easingOnly reads
- Added:draft_brand_checklistChanges things
- Added:dtcg_to_cssChanges things
- Added:error_message_checkChanges things
- Added:error_state_writer_templateChanges things
- Added:extract_design_tokensChanges things
- Added:generate_conformance_reportChanges things
- Added:inventory_componentsChanges things
- Added:label_clarity_checkChanges things
- Added:lint_brand_voiceChanges things
- Added:lint_disclosure_copyChanges things
- Added:lint_email_htmlChanges things
- Added:lint_lottie_jsonChanges things
- Added:localisation_readinessChanges things
- Added:logo_contrast_variantsChanges things
- Added:logo_size_rulesChanges things
- Added:measure_leadingChanges things
- Added:modular_scaleChanges things
- Added:naming_checkChanges things
- Added:nav_depth_checkOnly reads
- Added:notification_copy_checkChanges things
- Added:number_format_checkChanges things
- Added:page_weight_reportChanges things
- Added:palette_harmonyChanges things
- Added:plain_language_checkChanges things
- Added:plan_asset_exportsChanges things
- Added:plan_breakpointsChanges things
- Added:plan_durationsChanges things
- Added:plan_focus_orderChanges things
- Added:plan_impositionChanges things
- Added:plan_responsive_imagesChanges things
- Added:plan_staggerChanges things
- Added:plan_text_expansionChanges things
- Added:plan_usability_testChanges things
- Added:print_file_checklistOnly reads
- Added:rendered_vs_static_notesOnly reads
- Added:repeated_label_checkChanges things
- Added:review_animation_principlesChanges things
- Added:review_date_number_formatsChanges things
- Added:review_locale_pickerChanges things
- Added:review_microcopyChanges things
- Added:scan_piiChanges things
- Added:score_design_systemChanges things
- Added:screen_reader_scriptOnly reads
- Added:site_audit_summaryChanges things
- Added:site_consistencyChanges things
- Added:site_heading_outlineChanges things
- Added:site_inventoryChanges things
- Added:site_link_healthChanges things
- Added:site_meta_auditChanges things
- Added:site_page_diffOnly reads
- Added:site_performance_hintsChanges things
- Added:sitemap_to_outlineChanges things
- Added:stress_test_localisationChanges things
- Added:tagline_reviewChanges things
- Added:taxonomy_overlapOnly reads
- Added:tint_shade_scaleChanges things
- Added:touch_target_cssChanges things
- Added:tree_test_scorerOnly reads
- Added:trunk_testChanges things
- Added:type_crimes_lintChanges things
- Added:type_pairing_checkChanges things
- Added:url_structure_reviewChanges things
- Added:vertical_rhythmChanges things
- Added:write_design_changelogChanges things
- Changed:audit_page_accessibilityChanges thingsdescription
- Changed:check_contrastChanges thingsdescriptioninputSchema
- Changed:check_contrast_tokensChanges thingsdescription
- Changed:lint_research_questionsChanges thingsdescription
- Changed:lint_token_namesChanges thingsdescription
PostureRemote posture changed. Tools that change things, listed without credentials: 18 -> 125.View diff
- Tools that change things, listed without credentials: 18 to 125
Install
Pinned to version 1.1.0. Values in angle brackets are yours to fill in.
claude mcp add --transport http designers https://designers.allthepossibles.com/mcpclaude mcp add --transport http designers https://designers.allthepossibles.com/mcpRun in a terminal.
Claude Code permissions
Allow the reads, ask before a change or a way out, deny the deletes. Paste into .claude/settings.json.
{
"permissions": {
"allow": [
"mcp__designers__getting_started",
"mcp__designers__whoami",
"mcp__designers__get_project_context",
"mcp__designers__check_proximity_alignment",
"mcp__designers__colour_temperature_mix",
"mcp__designers__analyse_card_sort",
"mcp__designers__rendered_vs_static_notes",
"mcp__designers__compare_token_sets",
"mcp__designers__design_easing",
"mcp__designers__print_file_checklist",
"mcp__designers__nav_depth_check",
"mcp__designers__taxonomy_overlap",
"mcp__designers__tree_test_scorer"
],
"ask": [
"mcp__designers__check_contrast",
"mcp__designers__audit_page_accessibility",
"mcp__designers__heuristic_worksheet",
"mcp__designers__detect_design_slop",
"mcp__designers__review_ui_copy",
"mcp__designers__lint_design_feedback",
"mcp__designers__plan_critique",
"mcp__designers__lint_research_questions",
"mcp__designers__usability_stats",
"mcp__designers__lint_tracking_plan",
"mcp__designers__audit_site_accessibility",
"mcp__designers__check_contrast_tokens",
"mcp__designers__build_heuristic_report",
"mcp__designers__check_touch_targets",
"mcp__designers__lint_token_names",
"mcp__designers__lint_design_md",
"mcp__designers__doctor",
"mcp__designers__save_project_context",
"mcp__designers__generate_conformance_report",
"mcp__designers__screen_reader_script",
"mcp__designers__check_motion",
"mcp__designers__audit_email_accessibility",
"mcp__designers__check_reflow",
"mcp__designers__lint_disclosure_copy",
"mcp__designers__audit_dark_patterns",
"mcp__designers__lint_brand_voice",
"mcp__designers__stress_test_localisation",
"mcp__designers__scan_pii",
"mcp__designers__check_design_drift",
"mcp__designers__audit_form",
"mcp__designers__modular_scale",
"mcp__designers__measure_leading",
"mcp__designers__type_crimes_lint",
"mcp__designers__vertical_rhythm",
"mcp__designers__type_pairing_check",
"mcp__designers__build_grid",
"mcp__designers__build_spacing_scale",
"mcp__designers__calculate_proportion",
"mcp__designers__plan_breakpoints",
"mcp__designers__palette_harmony",
"mcp__designers__tint_shade_scale",
"mcp__designers__color_meaning_check",
"mcp__designers__dark_mode_palette",
"mcp__designers__trunk_test",
"mcp__designers__check_form",
"mcp__designers__calc_fitts_hick",
"mcp__designers__plan_usability_test",
"mcp__designers__chart_lint",
"mcp__designers__chart_chooser",
"mcp__designers__chart_colour_check",
"mcp__designers__data_table_vs_chart",
"mcp__designers__number_format_check",
"mcp__designers__css_contrast_pairs",
"mcp__designers__alt_text_quality",
"mcp__designers__error_message_check",
"mcp__designers__touch_target_css",
"mcp__designers__page_weight_report",
"mcp__designers__repeated_label_check",
"mcp__designers__site_inventory",
"mcp__designers__site_heading_outline",
"mcp__designers__site_meta_audit",
"mcp__designers__site_link_health",
"mcp__designers__site_consistency",
"mcp__designers__site_page_diff",
"mcp__designers__site_performance_hints",
"mcp__designers__site_audit_summary",
"mcp__designers__extract_design_tokens",
"mcp__designers__audit_token_scales",
"mcp__designers__audit_type_scale",
"mcp__designers__audit_spacing",
"mcp__designers__inventory_components",
"mcp__designers__check_state_coverage",
"mcp__designers__score_design_system",
"mcp__designers__dtcg_to_css",
"mcp__designers__css_to_dtcg",
"mcp__designers__draft_brand_checklist",
"mcp__designers__plan_durations",
"mcp__designers__audit_motion_css",
"mcp__designers__plan_stagger",
"mcp__designers__review_animation_principles",
"mcp__designers__lint_lottie_json",
"mcp__designers__lint_email_html",
"mcp__designers__check_email_preheader",
"mcp__designers__check_email_dark_mode",
"mcp__designers__check_email_accessibility",
"mcp__designers__check_email_subject",
"mcp__designers__calc_print_spec",
"mcp__designers__calc_print_resolution",
"mcp__designers__check_colour_mode",
"mcp__designers__convert_paper_size",
"mcp__designers__plan_imposition",
"mcp__designers__approx_print_colour",
"mcp__designers__logo_size_rules",
"mcp__designers__logo_contrast_variants",
"mcp__designers__brand_voice_consistency",
"mcp__designers__naming_check",
"mcp__designers__tagline_review",
"mcp__designers__brand_architecture_planner",
"mcp__designers__colour_palette_brief_check",
"mcp__designers__review_microcopy",
"mcp__designers__error_state_writer_template",
"mcp__designers__content_hierarchy_check",
"mcp__designers__plain_language_check",
"mcp__designers__localisation_readiness",
"mcp__designers__button_label_consistency",
"mcp__designers__notification_copy_check",
"mcp__designers__label_clarity_check",
"mcp__designers__url_structure_review",
"mcp__designers__sitemap_to_outline",
"mcp__designers__cognitive_load_check",
"mcp__designers__check_reading_order",
"mcp__designers__plan_focus_order",
"mcp__designers__check_keyboard_shortcuts",
"mcp__designers__check_input_modality",
"mcp__designers__check_rtl_readiness",
"mcp__designers__check_font_coverage",
"mcp__designers__review_date_number_formats",
"mcp__designers__plan_text_expansion",
"mcp__designers__check_name_fields",
"mcp__designers__check_cjk_line_breaking",
"mcp__designers__review_locale_picker",
"mcp__designers__check_handoff_spec",
"mcp__designers__check_naming_conventions",
"mcp__designers__plan_asset_exports",
"mcp__designers__plan_responsive_images",
"mcp__designers__audit_icon_set",
"mcp__designers__check_svg_bloat",
"mcp__designers__write_design_changelog"
],
"deny": []
}
}Tools that only read are allowed, tools that change things ask first, tools that delete or cancel are denied. A read that can send data out (it takes a URL, say) asks first too. It assumes the server is installed as designers. Review it before you use it.
Capability tags behind 37 rules
- mcp__designers__audit_page_accessibility untrusted-input, outbound
- mcp__designers__heuristic_worksheet untrusted-input, outbound
- mcp__designers__detect_design_slop untrusted-input, outbound
- mcp__designers__audit_site_accessibility untrusted-input, outbound
- mcp__designers__generate_conformance_report untrusted-input, outbound
- mcp__designers__screen_reader_script private-data, untrusted-input, outbound
- mcp__designers__check_motion untrusted-input, outbound
- mcp__designers__check_reflow untrusted-input, outbound
- mcp__designers__audit_dark_patterns untrusted-input, outbound
- mcp__designers__audit_form untrusted-input, outbound
- mcp__designers__trunk_test untrusted-input, outbound
- mcp__designers__check_form untrusted-input, outbound
- mcp__designers__css_contrast_pairs untrusted-input, outbound
- mcp__designers__alt_text_quality untrusted-input, outbound
- mcp__designers__touch_target_css untrusted-input, outbound
- mcp__designers__page_weight_report untrusted-input, outbound
- mcp__designers__repeated_label_check untrusted-input, outbound
- mcp__designers__rendered_vs_static_notes private-data, untrusted-input
- mcp__designers__site_inventory untrusted-input, outbound
- mcp__designers__site_heading_outline untrusted-input, outbound
- mcp__designers__site_meta_audit untrusted-input, outbound
- mcp__designers__site_link_health untrusted-input, outbound
- mcp__designers__site_consistency untrusted-input, outbound
- mcp__designers__site_page_diff untrusted-input, outbound
- mcp__designers__site_performance_hints untrusted-input, outbound
- mcp__designers__site_audit_summary untrusted-input, outbound
- mcp__designers__extract_design_tokens untrusted-input, outbound
- mcp__designers__audit_token_scales untrusted-input, outbound
- mcp__designers__audit_type_scale untrusted-input, outbound
- mcp__designers__audit_spacing untrusted-input, outbound
- mcp__designers__inventory_components untrusted-input, outbound
- mcp__designers__check_state_coverage untrusted-input, outbound
- mcp__designers__score_design_system untrusted-input, outbound
- mcp__designers__compare_token_sets untrusted-input
- mcp__designers__print_file_checklist private-data
- mcp__designers__notification_copy_check outbound
- mcp__designers__url_structure_review outbound
Pin
Keep the decision: fail CI when the tools change, follow every change, or show a badge.
Pin in CI
Fail a build when the tools you reviewed are not the tools the server serves today.
curl -s "https://radar.anlyon.com/api/v1/servers/com.allthepossibles/designers/verify?hash=a48d8fa4c02bbbba4d9487fbdaa3edee0db33bfdea9fd61f404e1eec2bccb4ac" | jq -e '.changed == false'Pinned hash a48d8fa4c02b, from Nov 11, 2026, 14:18 UTC.
Watch
Get told when its tools change: a new tool, a new description, a new class.
https://radar.anlyon.com/servers/com.allthepossibles/designers/changes.xmlAn Atom feed. Works in any feed reader or Slack's RSS app.
Badge
[](https://radar.anlyon.com/servers/com.allthepossibles/designers)Source: MCP Registry. Synced Oct 30, 2026, 00:17 UTC.
Designers MCP server: questions and answers
Answered from the scan above, not from the publisher's description.
Is the Designers MCP server safe?
- No scan can promise that. What its definitions show: 141 tools, 125 of which can change, send or delete something, and 21 findings from fixed checks. Allow the reads, ask before each change, and deny the deletes; the permissions block on this page does that.
Can the Designers MCP server delete data?
- No tool is classed as destructive: going by their definitions, none of them deletes, cancels or revokes anything.
Can the Designers MCP server do things that cannot be undone?
- No tool is classed as irreversible: none of them sends, pays, publishes or merges, going by their definitions.
What tools does the Designers MCP server have?
- 141 tools: 125 write, 16 read. check_contrast, audit_page_accessibility, heuristic_worksheet, detect_design_slop, review_ui_copy, lint_design_feedback, plan_critique, lint_research_questions and 133 more.
Does the Designers MCP server need sign-in or OAuth?
- Its remote endpoint listed its tools to an anonymous client, without sign-in.
Does the Designers MCP server send data to outside services?
- 34 tools can carry data out (it sends, posts or publishes, or takes a recipient, channel or URL): audit_page_accessibility, heuristic_worksheet, detect_design_slop, audit_site_accessibility, generate_conformance_report, screen_reader_script and 28 more.
Has the Designers MCP server changed its tools?
- Yes, once since Anlyon Radar started tracking it, most recently on Oct 30, 2026. Every change is on this page and in its Atom feed.