Designers MCP
An MCP server providing 141 deterministic tools for designers, including WCAG/APCA contrast checks, accessibility audits, Nielsen heuristics, AI design slop detection, UI copy review, and various linters for design tokens, feedback, and research questions.
Endpoint and access
No sign-in to connect and list tools. Individual tools may still need a vendor account, credentials, or permissions; check the documented prerequisites.
https://designers.allthepossibles.com/mcpWhat you can do with it
- Check text and UI color pairs against WCAG contrast standards
- Scan HTML pages for accessibility problems and WCAG criteria
- Detect common AI design defaults like eyebrow labels and arrow buttons
- Review UI copy for buttons, errors, and AI-writing tells
Source and maintenance
Protocol and capabilities
- Server
- designers 1.0.0
- MCP protocol
- 2025-06-18
- Tools
- 141 advertised
- Resources
- 15 advertised
- Resource templates
- 0 advertised
- Prompts
- 23 advertised
{
"tools": {
"listChanged": false
},
"prompts": {
"listChanged": false
},
"resources": {
"subscribe": false,
"listChanged": false
}
}Server-provided instructions
Untrusted server output shown for inspection. It is not Koskamo guidance and is excluded from knowledge search.
Tools
141 advertised
check_contrast — Contrast
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.
{
"type": "object",
"properties": {
"bg": {
"type": "string",
"description": "Background color"
},
"fg": {
"type": "string",
"description": "Foreground color"
},
"bold": {
"type": "boolean",
"description": "True if the text is bold, which changes the large-text threshold"
},
"pairs": {
"type": "array",
"items": {
"type": "object",
"properties": {
"bg": {
"type": "string"
},
"fg": {
"type": "string"
},
"bold": {
"type": "boolean"
},
"label": {
"type": "string"
},
"sizePx": {
"type": "number"
}
}
},
"description": "Several pairs at once"
},
"sizePx": {
"type": "number",
"description": "Text size in CSS px, default 16"
},
"palette": {
"type": "array",
"items": {
"type": "string"
},
"description": "Colors to test against white, black and each other under color blindness"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}audit_page_accessibility — Page accessibility
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.
{
"type": "object",
"properties": {
"url": {
"type": "string",
"description": "Public page to fetch"
},
"html": {
"type": "string",
"description": "Or paste HTML instead"
},
"compareUrl": {
"type": "string",
"description": "A second URL (for example the redesign): returns what was fixed, what is new and what remains"
}
}
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}heuristic_worksheet — Heuristic review
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.
{
"type": "object",
"properties": {
"url": {
"type": "string",
"description": "Public page to read instead of pasted text"
},
"html": {
"type": "string",
"description": "Page HTML, if you have it instead of a URL"
},
"task": {
"type": "string",
"description": "The task the reviewer is evaluating, e.g. 'change a billing address'"
},
"text": {
"type": "string",
"description": "Screen or flow copy"
}
}
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}detect_design_slop — AI design slop
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.
{
"type": "object",
"required": [
"url"
],
"properties": {
"url": {
"type": "string",
"description": "Public page to read"
},
"compareUrl": {
"type": "string",
"description": "A second URL: returns what became less or more generic"
}
}
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}review_ui_copy — UI copy
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.
{
"type": "object",
"properties": {
"text": {
"type": "string",
"description": "One string per line, e.g. 'button: Submit' or 'error: Invalid input'"
},
"items": {
"type": "array",
"items": {},
"description": "Or a list of strings or {text, type}"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}lint_design_feedback — Feedback lint
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.
{
"type": "object",
"required": [
"text"
],
"properties": {
"text": {
"type": "string",
"description": "One note per line, or paragraphs"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}plan_critique — Critique plan
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.
{
"type": "object",
"required": [
"description",
"stage"
],
"properties": {
"goal": {
"type": "string",
"description": "What the design has to achieve"
},
"stage": {
"enum": [
"concept",
"wireframe",
"visual",
"prototype",
"build",
"shipped"
],
"type": "string",
"description": "Where the work is now"
},
"minutes": {
"type": "integer",
"description": "Session length, 15 to 120, default 30"
},
"audience": {
"type": "string",
"description": "Who it is for"
},
"description": {
"type": "string",
"description": "A sentence or two about the design"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}lint_research_questions — Research questions
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.
{
"type": "object",
"required": [
"text"
],
"properties": {
"mode": {
"enum": [
"interview",
"survey"
],
"type": "string",
"description": "Default interview"
},
"text": {
"type": "string",
"description": "One question per line"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}usability_stats — Usability numbers
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.
{
"type": "object",
"properties": {
"p": {
"type": "number",
"description": "discovery: chance a participant hits a problem, default 0.31"
},
"lift": {
"type": "number",
"description": "ab: smallest relative lift to detect, percent"
},
"mode": {
"enum": [
"sus",
"discovery",
"ab",
"survey"
],
"type": "string",
"description": "Which calculator"
},
"alpha": {
"type": "number",
"description": "ab: significance level, 0.1, 0.05 or 0.01"
},
"power": {
"type": "number",
"description": "ab: 0.8, 0.9 or 0.95"
},
"margin": {
"type": "number",
"description": "survey: margin of error, e.g. 0.05"
},
"target": {
"type": "number",
"description": "discovery: share of problems to find, default 0.85"
},
"baseline": {
"type": "number",
"description": "ab: current conversion rate, e.g. 0.05"
},
"responses": {
"type": "array",
"items": {
"type": "array",
"items": {
"type": "integer"
}
},
"description": "sus: array of 10-number arrays"
},
"confidence": {
"type": "number",
"description": "survey: 0.9, 0.95 or 0.99"
},
"population": {
"type": "integer",
"description": "survey: total population, for the finite-population correction"
},
"dailyVisitors": {
"type": "integer",
"description": "ab: traffic per day, to estimate how long to run"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}lint_tracking_plan — Tracking plan
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.
{
"type": "object",
"properties": {
"text": {
"type": "string",
"description": "Events, one per line, or a JSON array"
},
"events": {
"type": "array",
"items": {},
"description": "Or a list of strings or {name, properties}"
},
"productType": {
"enum": [
"saas",
"ecommerce",
"marketplace",
"content",
"mobile"
],
"type": "string",
"description": "Draft a starter plan for this kind of product"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}audit_site_accessibility — Site accessibility crawl
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.
{
"type": "object",
"required": [
"url"
],
"properties": {
"url": {
"type": "string",
"description": "Start page"
},
"maxPages": {
"type": "integer",
"description": "2 to 15, default 10"
}
}
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}check_contrast_tokens — Token contrast matrix
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.
{
"type": "object",
"required": [
"tokens"
],
"properties": {
"tokens": {
"type": "string",
"description": "The token file contents"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}build_heuristic_report — Heuristic report
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.
{
"type": "object",
"required": [
"findings"
],
"properties": {
"task": {
"type": "string",
"description": "The task that was evaluated"
},
"title": {
"type": "string",
"description": "Report title"
},
"findings": {
"type": "array",
"items": {
"type": "object",
"required": [
"heuristic",
"severity",
"issue"
],
"properties": {
"fix": {
"type": "string"
},
"issue": {
"type": "string"
},
"effect": {
"type": "string"
},
"effort": {
"enum": [
"S",
"M",
"L"
],
"type": "string"
},
"location": {
"type": "string"
},
"severity": {
"type": "integer",
"maximum": 4,
"minimum": 0
},
"evaluator": {
"type": "string"
},
"heuristic": {
"type": "integer",
"maximum": 10,
"minimum": 1
}
}
},
"description": "Findings from the evaluation"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}getting_started — Getting started
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.
{
"type": "object",
"properties": {
"have": {
"type": "string",
"description": "What they have, in their own words, e.g. 'a Figma link and some button copy'"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}whoami — Plan and limits
Show the caller's plan (Free or Pro) and how many calls remain today on each tool. Does not use up a daily call.
{
"type": "object",
"properties": {}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}check_touch_targets — Touch targets
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.
{
"type": "object",
"properties": {
"text": {
"type": "string",
"description": "Or lines like 'Close icon 32x32 gap=4'"
},
"targets": {
"type": "array",
"items": {
"type": "object",
"required": [
"width",
"height"
],
"properties": {
"gap": {
"type": "number",
"description": "Spacing to the nearest other target"
},
"name": {
"type": "string"
},
"width": {
"type": "number"
},
"height": {
"type": "number"
},
"inline": {
"type": "boolean",
"description": "A link inside a sentence, which is exempt"
}
}
},
"description": "Targets to check"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}lint_token_names — Token names
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.
{
"type": "object",
"required": [
"text"
],
"properties": {
"text": {
"type": "string",
"description": "Token names or file contents"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}lint_design_md — DESIGN.md check
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.
{
"type": "object",
"required": [
"text"
],
"properties": {
"text": {
"type": "string",
"description": "The DESIGN.md contents"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}doctor — Doctor
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.
{
"type": "object",
"properties": {
"client": {
"type": "string",
"description": "Claude Desktop, claude.ai, Claude Code, Cursor, VS Code, Codex or ChatGPT"
},
"symptom": {
"type": "string",
"description": "What is going wrong, in the person's words"
},
"figmaLink": {
"type": "string",
"description": "A Figma link to check"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}save_project_context — Save project context
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.
{
"type": "object",
"required": [
"name",
"content"
],
"properties": {
"name": {
"type": "string",
"description": "e.g. design-md, brand-voice"
},
"content": {
"type": "string",
"description": "The text to save"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}get_project_context — Get project context
Pro. List the saved project context, or read one item by name.
{
"type": "object",
"properties": {
"name": {
"type": "string",
"description": "Omit to list everything saved"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}generate_conformance_report — Conformance report
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.
{
"type": "object",
"properties": {
"url": {
"type": "string",
"description": "A single public page URL, instead of urls"
},
"urls": {
"type": "array",
"items": {
"type": "string"
},
"maxItems": 10,
"description": "Up to 10 public page URLs that represent the product (home, a form, a content page, sign-in)"
},
"vendor": {
"type": "string",
"description": "Company that makes the product"
},
"version": {
"type": "string",
"description": "Product version or release date"
},
"evaluator": {
"type": "string",
"description": "Person or team who ran the evaluation"
},
"productName": {
"type": "string",
"description": "Product name for the report header"
},
"contactEmail": {
"type": "string",
"description": "Contact for accessibility questions"
}
}
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}screen_reader_script — Screen reader script
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.
{
"type": "object",
"properties": {
"url": {
"type": "string",
"description": "Public page to fetch instead of pasting HTML"
},
"html": {
"type": "string",
"description": "HTML of the page or component to read"
}
}
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}check_motion — Motion check
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.
{
"type": "object",
"properties": {
"css": {
"type": "string",
"description": "CSS text to analyze, with or without html."
},
"url": {
"type": "string",
"description": "A public page to fetch instead. Up to 4 same-site stylesheets are fetched too."
},
"html": {
"type": "string",
"description": "Page HTML source. Optional if url is given."
}
},
"additionalProperties": false
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}audit_email_accessibility — Email accessibility audit
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.
{
"type": "object",
"required": [
"html"
],
"properties": {
"html": {
"type": "string",
"description": "The full HTML source of the email."
}
},
"additionalProperties": false
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}check_reflow — Reflow and resize check
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.
{
"type": "object",
"properties": {
"css": {
"type": "string",
"description": "CSS text to analyze, with or without html."
},
"url": {
"type": "string",
"description": "A public page to fetch instead. Up to 4 same-site stylesheets are fetched too."
},
"html": {
"type": "string",
"description": "Page HTML source. Optional if url is given."
}
},
"additionalProperties": false
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}lint_disclosure_copy — Disclosure copy
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.
{
"type": "object",
"required": [
"text"
],
"properties": {
"kind": {
"enum": [
"fee",
"rate",
"terms",
"consent",
"privacy",
"error",
"marketing"
],
"type": "string",
"description": "What the copy is, which picks the checklist: fee, rate, terms, consent, privacy, error or marketing. Guessed from the text if omitted."
},
"text": {
"type": "string",
"description": "The copy to check, as paragraphs or one sentence per line"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}audit_dark_patterns — Dark patterns
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.
{
"type": "object",
"properties": {
"url": {
"type": "string",
"description": "Public page to fetch and check (static HTML only)"
},
"html": {
"type": "string",
"description": "Page or component HTML, to catch checked inputs, timers and control styling"
},
"text": {
"type": "string",
"description": "Screen copy and control labels, one per line, with optional prefixes such as button:, link:, checkbox:, text:. You can describe flows too: 'signup: 2 steps', 'cancel: 6 steps'."
}
}
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}lint_brand_voice — Brand voice
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.
{
"type": "object",
"required": [
"text",
"rules"
],
"properties": {
"text": {
"type": "string",
"description": "The copy to check. Use # lines or 'heading:' prefixes to mark headings."
},
"rules": {
"oneOf": [
{
"type": "string"
},
{
"type": "object"
},
{
"type": "array",
"items": {}
}
],
"description": "Voice rules: plain lines (one rule per line) or a JSON object such as {\"banned\": [...], \"preferred\": {\"log in\": \"sign in\"}, \"products\": [...], \"headings\": \"sentence\", \"maxSentenceWords\": 20, \"punctuation\": [\"!\"], \"required\": [...], \"tone\": [...]}"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}stress_test_localisation — Localisation stress test
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.
{
"type": "object",
"required": [
"strings"
],
"properties": {
"locales": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "Locale codes to test, comma separated or an array. Default: de, fr, es, fi, ru, ja, ar, zh"
},
"strings": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {}
}
],
"description": "UI strings, one per line ('Save | 8' sets a 8-char limit; 'label | text | 24' also sets a label), or a JSON array of strings or {text, maxChars, label}"
},
"defaultMaxChars": {
"type": "integer",
"description": "Character limit applied to strings that do not have their own"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}scan_pii — Personal data scan
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.
{
"type": "object",
"required": [
"text"
],
"properties": {
"mode": {
"enum": [
"design",
"strict"
],
"type": "string",
"description": "design (default) skips name detection and bare 7-digit phone numbers; strict adds them and accepts more false positives."
},
"text": {
"type": "string",
"description": "The text to scan. Up to 100,000 characters on the free tier."
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}check_design_drift — Design drift check
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.
{
"type": "object",
"required": [
"design",
"code"
],
"properties": {
"code": {
"type": "string",
"description": "CSS, SCSS or Tailwind theme text from the codebase."
},
"design": {
"type": "string",
"description": "Design tokens: W3C or Tokens Studio JSON, flat key/value JSON, or CSS variables."
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}audit_form — Form audit
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.
{
"type": "object",
"properties": {
"url": {
"type": "string",
"description": "Public page to fetch and audit."
},
"html": {
"type": "string",
"description": "Form or page HTML. Use this or url."
},
"errors": {
"type": "string",
"description": "Optional error messages to review, one per line."
}
}
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}modular_scale — Modular type scale
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.
{
"type": "object",
"properties": {
"base": {
"type": "number",
"description": "Body size in px (8 to 64, default 16)."
},
"ratio": {
"description": "A number (1.01 to 4) or a name such as \"major third\", \"perfect fourth\", \"golden\". Default major third."
},
"rootPx": {
"type": "number",
"description": "Root font size for rem conversion (default 16)."
},
"minBase": {
"type": "number",
"description": "Base size at the small viewport (default same as base)."
},
"stepsUp": {
"type": "integer",
"description": "Steps above the base (0 to 12, default 6)."
},
"minRatio": {
"description": "Ratio at the small viewport, number or name (default: 20 percent closer to 1 than ratio)."
},
"stepsDown": {
"type": "integer",
"description": "Steps below the base (0 to 6, default 2)."
},
"maxViewport": {
"type": "number",
"description": "Viewport width in px where the fluid scale reaches full size (default 1280)."
},
"minViewport": {
"type": "number",
"description": "Viewport width in px where the fluid scale uses its small values (default 320)."
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}measure_leading — Measure and leading
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.
{
"type": "object",
"required": [
"fontSizePx",
"containerPx"
],
"properties": {
"language": {
"type": "string",
"description": "Two-letter language code (default en)."
},
"fontSizePx": {
"type": "number",
"description": "Font size in px."
},
"containerPx": {
"type": "number",
"description": "Width of the text column in px."
},
"charsPerLine": {
"type": "number",
"description": "Optional counted characters per line, used instead of the estimate."
},
"avgCharWidthEm": {
"type": "number",
"description": "Optional average character width as a fraction of the font size (default 0.5)."
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}type_crimes_lint — Type crimes lint
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.
{
"type": "object",
"required": [
"text"
],
"properties": {
"kind": {
"enum": [
"auto",
"text",
"html",
"css"
],
"type": "string",
"description": "Input type (default auto-detect)."
},
"text": {
"type": "string",
"description": "Copy, HTML or CSS to check. Up to 100,000 characters on the free tier."
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}vertical_rhythm — Vertical rhythm
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.
{
"type": "object",
"required": [
"sizes"
],
"properties": {
"sizes": {
"type": "array",
"items": {},
"description": "Font sizes in px, or \"name:size\" strings, up to 30."
},
"rootPx": {
"type": "number",
"description": "Root font size for rem output (default 16)."
},
"baseline": {
"type": "number",
"description": "Baseline unit in px (2 to 48, default 8)."
},
"bodySize": {
"type": "number",
"description": "Body font size in px (default 16)."
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}type_pairing_check — Type pairing check
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).
{
"type": "object",
"required": [
"fonts"
],
"properties": {
"fonts": {
"type": "array",
"items": {
"type": "string"
},
"description": "Two or three font names, optionally \"Name:role\", for example [\"Champion Gothic:heading\", \"Caslon:body\", \"Trade Gothic:ui\"]."
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}build_grid — Grid builder
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.
{
"type": "object",
"required": [
"width"
],
"properties": {
"rows": {
"type": "integer",
"description": "Rows for the modular variant (needs `height`)."
},
"width": {
"type": "number",
"description": "Page or container width in px."
},
"gutter": {
"type": "number",
"description": "Gutter in px (default 24, 0 allowed)."
},
"height": {
"type": "number",
"description": "Page height in px for the modular variant."
},
"margin": {
"type": "number",
"description": "Outer margin on each side in px (default 24, 0 allowed)."
},
"columns": {
"type": "integer",
"description": "Number of columns (default 12, max 64)."
},
"baseline": {
"type": "number",
"description": "Baseline unit in px, to check module alignment."
},
"rowGutter": {
"type": "number",
"description": "Gutter between rows in px (default: the column gutter)."
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}build_spacing_scale — Spacing scale
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.
{
"type": "object",
"properties": {
"base": {
"type": "number",
"description": "Base unit in px (default 8)."
},
"count": {
"type": "integer",
"description": "How many tokens (default 10)."
},
"ratio": {
"type": "number",
"description": "Modular ratio, for example 1.5 or 1.25. Omit for a linear scale."
},
"steps": {
"type": "array",
"items": {
"type": "number"
},
"description": "Your own step list in px, for example [4, 8, 12, 16, 24, 40]."
},
"prefix": {
"type": "string",
"description": "Custom property prefix (default space)."
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}calculate_proportion — Proportion calculator
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.
{
"type": "object",
"properties": {
"ratio": {
"type": "string",
"description": "golden, root2, a-series, 3:2, 16:9, 4:5, a decimal like 1.414, or any a:b. Default golden."
},
"width": {
"type": "number",
"description": "Known width in px (or any unit)."
},
"height": {
"type": "number",
"description": "Known height. Give one of width or height; give both to get crop suggestions."
},
"container": {
"type": "number",
"description": "Length to split into major and minor parts."
},
"orientation": {
"enum": [
"landscape",
"portrait"
],
"type": "string",
"description": "Landscape (default) makes the width the long side."
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}plan_breakpoints — Breakpoint planner
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.
{
"type": "object",
"required": [
"contentWidths"
],
"properties": {
"gutter": {
"type": "number",
"description": "Gutter in px (default 24)."
},
"margin": {
"type": "number",
"description": "Page margin per side in px (default 24)."
},
"fluidMax": {
"type": "number",
"description": "Viewport where fluid values stop (default 1440)."
},
"fluidMin": {
"type": "number",
"description": "Viewport where fluid values start (default 320)."
},
"fontSize": {
"type": "number",
"description": "Body size in px (default 16)."
},
"maxColumns": {
"type": "integer",
"description": "Most text columns you will show (default 3, max 6)."
},
"maxMeasure": {
"type": "number",
"description": "Maximum characters per line (default 75)."
},
"minMeasure": {
"type": "number",
"description": "Minimum characters per line (default 45)."
},
"contentWidths": {
"type": "array",
"items": {
"type": "number"
},
"description": "Widths in px where the layout needs to change. Comma separated string also accepted."
},
"deviceTargets": {
"type": "array",
"items": {
"type": "number"
},
"description": "Device widths to check against the result, for example [390, 768, 1280]."
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}check_proximity_alignment — Proximity and alignment check
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.
{
"type": "object",
"properties": {
"css": {
"type": "string",
"description": "CSS for the markup (simple class, id and tag selectors)."
},
"html": {
"type": "string",
"description": "Markup with positioned elements (alternative to boxes)."
},
"boxes": {
"type": "array",
"items": {
"type": "object",
"properties": {
"h": {
"type": "number"
},
"w": {
"type": "number"
},
"x": {
"type": "number"
},
"y": {
"type": "number"
},
"label": {
"type": "string"
}
}
},
"description": "Boxes as {x, y, w, h, label}. A JSON string is also accepted."
},
"tolerance": {
"type": "number",
"description": "Near-miss window in px (default 6, max 50)."
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}palette_harmony — Palette harmony
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.
{
"type": "object",
"required": [
"colors"
],
"properties": {
"colors": {
"anyOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "One to six base colors: a string such as \"#1b3a5c, #e4572e\" or an array of strings."
},
"harmony": {
"enum": [
"complementary",
"analogous",
"triadic",
"split-complementary",
"tetradic"
],
"type": "string",
"description": "Return only this harmony. Omit for all five."
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}tint_shade_scale — Tint and shade scale
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.
{
"type": "object",
"required": [
"color"
],
"properties": {
"name": {
"type": "string",
"description": "Optional name for the CSS variables, such as blue."
},
"color": {
"type": "string",
"description": "Base color, such as #2f6fed."
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}color_meaning_check — Status color check
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.
{
"type": "object",
"required": [
"states"
],
"properties": {
"states": {
"anyOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "object",
"required": [
"color"
],
"properties": {
"color": {
"type": "string"
},
"label": {
"type": "string"
}
}
}
]
}
}
],
"description": "State colors with labels: \"error: #d32f2f, success: #2e7d32\" or an array of {label, color}."
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}dark_mode_palette — Dark mode palette
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.
{
"type": "object",
"required": [
"tokens"
],
"properties": {
"tokens": {
"anyOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "object",
"required": [
"color"
],
"properties": {
"name": {
"type": "string"
},
"color": {
"type": "string"
}
}
}
}
],
"description": "Light tokens: \"bg: #fff\\ntext: #111\\nprimary: #2563eb\", a JSON object, or an array of {name, color}."
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}colour_temperature_mix — Color temperature mix
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.
{
"type": "object",
"required": [
"colors"
],
"properties": {
"colors": {
"anyOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "object",
"required": [
"color"
],
"properties": {
"color": {
"type": "string"
},
"share": {
"type": "number"
}
}
}
]
}
}
],
"description": "The palette, optionally with shares: \"#1b3a5c 55%, #f2efe6 30%, #e4572e 15%\"."
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}trunk_test — Trunk test
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.
{
"type": "object",
"properties": {
"url": {
"type": "string",
"description": "Public page to fetch."
},
"html": {
"type": "string",
"description": "Page HTML, or plain page text. Use this, text or url."
}
}
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}check_form — Form check
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.
{
"type": "object",
"properties": {
"url": {
"type": "string",
"description": "Public page to fetch."
},
"html": {
"type": "string",
"description": "Form or page HTML. Use this or url."
}
}
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}analyse_card_sort — Card sort analyzer
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.
{
"type": "object",
"required": [
"participants"
],
"properties": {
"threshold": {
"type": "number",
"description": "Cluster cut-off as percent agreement, 10 to 95. Default 50."
},
"participants": {
"type": "array",
"items": {
"type": "object"
},
"description": "One entry per participant: {\"Group name\": [\"card\", ...]} or {id, groups}."
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}calc_fitts_hick — Fitts and Hick calculator
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.
{
"type": "object",
"properties": {
"width": {
"type": "number",
"description": "Target width along the movement line, same unit."
},
"hick_a": {
"type": "number",
"description": "Hick intercept in ms. Default 200."
},
"hick_b": {
"type": "number",
"description": "Hick slope in ms per bit. Default 150."
},
"choices": {
"type": "integer",
"description": "Number of equally likely choices."
},
"fitts_a": {
"type": "number",
"description": "Fitts intercept in ms. Default 100."
},
"fitts_b": {
"type": "number",
"description": "Fitts slope in ms per bit. Default 150."
},
"layouts": {
"type": "array",
"items": {
"type": "object",
"properties": {
"name": {
"type": "string"
},
"choices": {
"type": "integer"
},
"targets": {
"type": "array",
"items": {
"type": "object",
"properties": {
"label": {
"type": "string"
},
"width": {
"type": "number"
},
"distance": {
"type": "number"
}
}
}
}
}
},
"description": "2 or 3 layouts to compare."
},
"distance": {
"type": "number",
"description": "Distance to target along the movement line, any consistent unit."
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}plan_usability_test — Usability test plan
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.
{
"type": "object",
"required": [
"goal",
"tasks"
],
"properties": {
"goal": {
"type": "string",
"description": "What the study needs to learn."
},
"tasks": {
"type": "array",
"items": {},
"description": "Task strings or {name, scenario, start, success}."
},
"method": {
"enum": [
"moderated",
"unmoderated"
],
"type": "string"
},
"product": {
"type": "string"
},
"participants": {
"description": "Number, list of criteria, or {count, groups, profile}."
},
"session_minutes": {
"type": "number",
"description": "Session length, default 45."
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}chart_lint — Chart honesty check
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.
{
"type": "object",
"required": [
"spec"
],
"properties": {
"spec": {
"anyOf": [
{
"type": "object"
},
{
"type": "string"
}
],
"description": "Chart spec as a JSON object or a JSON string. See the tool description for fields."
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}chart_chooser — Chart chooser
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.
{
"type": "object",
"required": [
"question"
],
"properties": {
"points": {
"type": "number",
"description": "Number of observations or time points."
},
"series": {
"type": "number",
"description": "Number of series."
},
"audience": {
"enum": [
"general",
"analyst"
],
"type": "string",
"description": "Who reads it."
},
"overTime": {
"type": "boolean",
"description": "The question spans time."
},
"question": {
"enum": [
"compare",
"trend",
"distribution",
"part-to-whole",
"relationship",
"ranking",
"geography"
],
"type": "string",
"description": "What the reader should be able to answer."
},
"hierarchy": {
"type": "boolean",
"description": "Parts nest inside parts (part-to-whole)."
},
"categories": {
"type": "number",
"description": "Number of categories or items."
},
"thirdVariable": {
"type": "boolean",
"description": "A third measure is available (relationship)."
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}chart_colour_check — Chart color check
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.
{
"type": "object",
"required": [
"colors"
],
"properties": {
"colors": {
"anyOf": [
{
"type": "array",
"items": {
"type": "string"
}
},
{
"type": "string"
}
],
"description": "Series colors, as a list or comma-separated string."
},
"chartType": {
"type": "string",
"description": "bar, column, line, area, pie, scatter, map, stacked..."
},
"background": {
"type": "string",
"description": "Chart background color. Default #ffffff."
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}data_table_vs_chart — Table or chart
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.
{
"type": "object",
"required": [
"rows",
"cols",
"purpose"
],
"properties": {
"cols": {
"type": "number"
},
"rows": {
"type": "number"
},
"space": {
"enum": [
"inline",
"tiny",
"normal",
"large"
],
"type": "string"
},
"groups": {
"type": "number"
},
"purpose": {
"enum": [
"lookup",
"compare",
"pattern",
"monitor"
],
"type": "string"
},
"audience": {
"enum": [
"general",
"analyst",
"executive"
],
"type": "string"
},
"precision": {
"enum": [
"exact",
"approximate"
],
"type": "string"
},
"mixedUnits": {
"type": "boolean"
},
"timeSeries": {
"type": "boolean"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}number_format_check — Number format check
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.
{
"type": "object",
"required": [
"numbers",
"context"
],
"properties": {
"raw": {
"type": "array",
"items": {
"type": "number"
},
"description": "Unrounded values in the same order as `numbers`."
},
"total": {
"type": "number",
"description": "Stated total of the displayed parts."
},
"locale": {
"type": "string",
"description": "BCP 47 locale such as en-US or de-DE."
},
"context": {
"enum": [
"axis",
"tooltip",
"table cell",
"headline"
],
"type": "string"
},
"numbers": {
"anyOf": [
{
"type": "array",
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "number"
}
]
}
},
{
"type": "string"
}
],
"description": "Numbers as displayed."
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}css_contrast_pairs — CSS contrast pairs
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.
{
"type": "object",
"properties": {
"css": {
"type": "string",
"description": "CSS source to check."
},
"url": {
"type": "string",
"description": "A public page URL to fetch."
},
"html": {
"type": "string",
"description": "Optional HTML whose <style> blocks are read."
},
"scheme": {
"enum": [
"both",
"light",
"dark"
],
"type": "string",
"description": "Which color scheme to evaluate. Default both."
},
"viewport": {
"type": "number",
"description": "Viewport width in px for width media queries. Default 1280."
}
},
"additionalProperties": false
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}alt_text_quality — Alt text quality
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.
{
"type": "object",
"properties": {
"url": {
"type": "string",
"description": "A public page URL to fetch."
},
"html": {
"type": "string",
"description": "HTML source to check instead of a URL."
}
},
"additionalProperties": false
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}error_message_check — Error message check
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.
{
"type": "object",
"required": [
"messages"
],
"properties": {
"messages": {
"type": "array",
"items": {
"anyOf": [
{
"type": "string"
},
{
"type": "object",
"required": [
"text"
],
"properties": {
"text": {
"type": "string"
},
"where": {
"type": "string",
"description": "inline, toast, tooltip, placeholder, banner, modal"
},
"autoDismissMs": {
"type": "number"
}
}
}
]
},
"maxItems": 300,
"description": "Error and status strings, one per item."
}
},
"additionalProperties": false
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}touch_target_css — Touch target estimate from CSS
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.
{
"type": "object",
"properties": {
"css": {
"type": "string",
"description": "CSS source."
},
"url": {
"type": "string",
"description": "A public page URL to fetch."
},
"html": {
"type": "string",
"description": "HTML markup."
},
"viewport": {
"type": "number",
"description": "Viewport width in px for media queries. Default 390."
}
},
"additionalProperties": false
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}page_weight_report — Page weight report
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.
{
"type": "object",
"required": [
"url"
],
"properties": {
"url": {
"type": "string",
"description": "A public page URL to fetch."
}
},
"additionalProperties": false
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}repeated_label_check — Repeated labels check
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.
{
"type": "object",
"properties": {
"url": {
"type": "string",
"description": "A public page URL to fetch."
},
"html": {
"type": "string",
"description": "HTML source to check instead of a URL."
}
},
"additionalProperties": false
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}rendered_vs_static_notes — Rendered versus static notes
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.
{
"type": "object",
"properties": {
"finding": {
"type": "string",
"description": "Finding type, tool name, WCAG number or plain description. Omit to list all."
}
},
"additionalProperties": false
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}site_inventory — Site inventory
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.
{
"type": "object",
"required": [
"url"
],
"properties": {
"url": {
"type": "string",
"description": "Home page or any page on the site. The crawl stays on this origin."
},
"paths": {
"type": "array",
"items": {
"type": "string"
},
"description": "Optional list of same-origin paths such as /about. When given, only these pages are read and links are not followed."
},
"sitemap": {
"type": "boolean",
"description": "Use sitemap.xml to find pages. Default true."
},
"maxPages": {
"type": "number",
"description": "Optional lower page cap. The hard cap is 40 pages."
}
}
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}site_heading_outline — Site heading outline
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.
{
"type": "object",
"required": [
"url"
],
"properties": {
"url": {
"type": "string",
"description": "Home page or any page on the site. The crawl stays on this origin."
},
"paths": {
"type": "array",
"items": {
"type": "string"
},
"description": "Optional list of same-origin paths such as /about. When given, only these pages are read and links are not followed."
},
"sitemap": {
"type": "boolean",
"description": "Use sitemap.xml to find pages. Default true."
},
"maxPages": {
"type": "number",
"description": "Optional lower page cap. The hard cap is 40 pages."
}
}
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}site_meta_audit — Site meta audit
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.
{
"type": "object",
"required": [
"url"
],
"properties": {
"url": {
"type": "string",
"description": "Home page or any page on the site. The crawl stays on this origin."
},
"paths": {
"type": "array",
"items": {
"type": "string"
},
"description": "Optional list of same-origin paths such as /about. When given, only these pages are read and links are not followed."
},
"sitemap": {
"type": "boolean",
"description": "Use sitemap.xml to find pages. Default true."
},
"maxPages": {
"type": "number",
"description": "Optional lower page cap. The hard cap is 40 pages."
}
}
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}site_link_health — Site link health
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.
{
"type": "object",
"required": [
"url"
],
"properties": {
"url": {
"type": "string",
"description": "Home page or any page on the site. The crawl stays on this origin."
},
"paths": {
"type": "array",
"items": {
"type": "string"
},
"description": "Optional list of same-origin paths such as /about. When given, only these pages are read and links are not followed."
},
"sitemap": {
"type": "boolean",
"description": "Use sitemap.xml to find pages. Default true."
},
"maxPages": {
"type": "number",
"description": "Optional lower page cap. The hard cap is 40 pages."
},
"maxLinkChecks": {
"type": "number",
"description": "Optional lower cap on extra link requests. The hard cap is 60."
}
}
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}site_consistency — Site consistency
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.
{
"type": "object",
"required": [
"url"
],
"properties": {
"url": {
"type": "string",
"description": "Home page or any page on the site. The crawl stays on this origin."
},
"paths": {
"type": "array",
"items": {
"type": "string"
},
"description": "Optional list of same-origin paths such as /about. When given, only these pages are read and links are not followed."
},
"sitemap": {
"type": "boolean",
"description": "Use sitemap.xml to find pages. Default true."
},
"maxPages": {
"type": "number",
"description": "Optional lower page cap. The hard cap is 40 pages."
}
}
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}site_page_diff — Page diff
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.
{
"type": "object",
"required": [
"url",
"compareUrl"
],
"properties": {
"url": {
"type": "string",
"description": "First page (for example production)"
},
"compareUrl": {
"type": "string",
"description": "Second page (for example staging). Must differ from url."
}
}
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}site_performance_hints — Site performance hints
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.
{
"type": "object",
"required": [
"url"
],
"properties": {
"url": {
"type": "string",
"description": "Home page or any page on the site. The crawl stays on this origin."
},
"paths": {
"type": "array",
"items": {
"type": "string"
},
"description": "Optional list of same-origin paths such as /about. When given, only these pages are read and links are not followed."
},
"sitemap": {
"type": "boolean",
"description": "Use sitemap.xml to find pages. Default true."
},
"maxPages": {
"type": "number",
"description": "Optional lower page cap. The hard cap is 40 pages."
}
}
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}site_audit_summary — Site audit summary
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.
{
"type": "object",
"required": [
"url"
],
"properties": {
"url": {
"type": "string",
"description": "Home page or any page on the site. The crawl stays on this origin."
},
"paths": {
"type": "array",
"items": {
"type": "string"
},
"description": "Optional list of same-origin paths such as /about. When given, only these pages are read and links are not followed."
},
"sitemap": {
"type": "boolean",
"description": "Use sitemap.xml to find pages. Default true."
},
"maxPages": {
"type": "number",
"description": "Optional lower page cap. The hard cap is 40 pages."
},
"maxLinkChecks": {
"type": "number",
"description": "Optional lower cap on extra link requests. The hard cap is 60."
}
}
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}extract_design_tokens — Extract design tokens
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.
{
"type": "object",
"properties": {
"css": {
"type": "string",
"description": "CSS text to read (a stylesheet, or several concatenated). Free up to 100,000 characters; Pro up to 2,000,000."
},
"url": {
"type": "string",
"description": "Pro only. Public page whose linked and inline stylesheets are fetched (up to 12 sheets, 5 MB)."
}
}
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}audit_token_scales — Token scale audit
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.
{
"type": "object",
"properties": {
"css": {
"type": "string",
"description": "CSS text to read (a stylesheet, or several concatenated). Free up to 100,000 characters; Pro up to 2,000,000."
},
"url": {
"type": "string",
"description": "Pro only. Public page whose linked and inline stylesheets are fetched (up to 12 sheets, 5 MB)."
},
"values": {
"type": "object",
"description": "Alternative to css: {colors?: string[], fontSizes?: string[], spacing?: string[], radii?: string[]}. Items may be {value, count}."
}
}
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}audit_type_scale — Type scale audit
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.
{
"type": "object",
"properties": {
"css": {
"type": "string",
"description": "CSS text to read (a stylesheet, or several concatenated). Free up to 100,000 characters; Pro up to 2,000,000."
},
"url": {
"type": "string",
"description": "Pro only. Public page whose linked and inline stylesheets are fetched (up to 12 sheets, 5 MB)."
}
}
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}audit_spacing — Spacing audit
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.
{
"type": "object",
"properties": {
"css": {
"type": "string",
"description": "CSS text to read (a stylesheet, or several concatenated). Free up to 100,000 characters; Pro up to 2,000,000."
},
"url": {
"type": "string",
"description": "Pro only. Public page whose linked and inline stylesheets are fetched (up to 12 sheets, 5 MB)."
}
}
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}inventory_components — Component inventory
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.
{
"type": "object",
"properties": {
"css": {
"type": "string",
"description": "CSS text to read (a stylesheet, or several concatenated). Free up to 100,000 characters; Pro up to 2,000,000."
},
"url": {
"type": "string",
"description": "Pro only. Public page whose linked and inline stylesheets are fetched (up to 12 sheets, 5 MB)."
},
"html": {
"type": "string",
"description": "Optional page markup. Any <style> blocks in it are read as CSS too."
}
}
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}check_state_coverage — State coverage check
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).
{
"type": "object",
"properties": {
"css": {
"type": "string",
"description": "CSS text to read (a stylesheet, or several concatenated). Free up to 100,000 characters; Pro up to 2,000,000."
},
"url": {
"type": "string",
"description": "Pro only. Public page whose linked and inline stylesheets are fetched (up to 12 sheets, 5 MB)."
}
}
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}score_design_system — Design system health score
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.
{
"type": "object",
"properties": {
"css": {
"type": "string",
"description": "CSS text to read (a stylesheet, or several concatenated). Free up to 100,000 characters; Pro up to 2,000,000."
},
"url": {
"type": "string",
"description": "Pro only. Public page whose linked and inline stylesheets are fetched (up to 12 sheets, 5 MB)."
},
"html": {
"type": "string",
"description": "Optional page markup. Any <style> blocks in it are read as CSS too."
},
"pairs": {
"anyOf": [
{
"type": "string"
},
{
"type": "array"
}
],
"description": "Optional stated pairs: an array of {foreground, background, label} or a string with one pair per line."
}
}
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}compare_token_sets — Token drift compare
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.
{
"type": "object",
"properties": {
"after": {
"anyOf": [
{
"type": "string"
},
{
"type": "object"
}
],
"description": "Later token set, same formats."
},
"before": {
"anyOf": [
{
"type": "string"
},
{
"type": "object"
}
],
"description": "Earlier token set: CSS, DTCG JSON or flat JSON."
},
"after_url": {
"type": "string",
"description": "Pro only. Public page whose linked and inline stylesheets are fetched (up to 12 sheets, 5 MB)."
},
"before_url": {
"type": "string",
"description": "Pro only. Public page whose linked and inline stylesheets are fetched (up to 12 sheets, 5 MB)."
}
}
}{
"readOnlyHint": true,
"openWorldHint": true,
"destructiveHint": false
}dtcg_to_css — Design tokens to CSS
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.
{
"type": "object",
"required": [
"tokens"
],
"properties": {
"format": {
"enum": [
"css",
"tailwind",
"both"
],
"type": "string",
"description": "Default both."
},
"prefix": {
"type": "string",
"description": "Optional prefix for CSS variable names, e.g. ds gives --ds-color-brand."
},
"tokens": {
"anyOf": [
{
"type": "string"
},
{
"type": "object"
}
],
"description": "W3C design tokens as JSON text or an object."
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}css_to_dtcg — CSS to design tokens
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.
{
"type": "object",
"required": [
"css"
],
"properties": {
"css": {
"type": "string",
"description": "CSS with custom properties. Free up to 100,000 characters; Pro up to 2,000,000."
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}draft_brand_checklist — Brand guideline checklist
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.
{
"type": "object",
"required": [
"name"
],
"properties": {
"name": {
"type": "string",
"description": "Brand or product name."
},
"tone": {
"anyOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "Tone words, comma separated or a list."
},
"audience": {
"anyOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "Who it is for."
},
"constraints": {
"anyOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "Constraints, one per line or a list."
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}design_easing — Easing designer
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.
{
"type": "object",
"required": [
"easing"
],
"properties": {
"mass": {
"type": "number",
"description": "Spring mass, default 1"
},
"easing": {
"type": "string",
"description": "Name, cubic-bezier(x1,y1,x2,y2) or spring"
},
"damping": {
"type": "number",
"description": "Spring damping, default 26"
},
"stiffness": {
"type": "number",
"description": "Spring stiffness, default 170"
},
"duration_ms": {
"type": "number",
"description": "Duration in ms (bezier only), 1 to 10000"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}plan_durations — Duration scale
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.
{
"type": "object",
"required": [
"distance_px"
],
"properties": {
"kind": {
"enum": [
"enter",
"exit",
"state-change"
],
"type": "string",
"description": "enter, exit or state-change"
},
"size": {
"enum": [
"small",
"medium",
"large",
"fullscreen"
],
"type": "string",
"description": "Element size"
},
"allow_long": {
"enum": [
"false",
"true"
],
"type": "string",
"description": "Lift the 400 ms UI cap"
},
"complexity": {
"enum": [
"simple",
"moderate",
"complex"
],
"type": "string",
"description": "How many things move or change at once"
},
"distance_px": {
"type": "number",
"description": "Distance travelled in px, 0 to 5000"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}audit_motion_css — Motion CSS audit
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.
{
"type": "object",
"required": [
"css"
],
"properties": {
"css": {
"type": "string",
"description": "CSS to audit"
},
"flash_area_percent": {
"type": "number",
"description": "Share of screen that flashes, 0 to 100"
},
"flashes_per_second": {
"type": "number",
"description": "Flashes per second, if known"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}plan_stagger — Stagger planner
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).
{
"type": "object",
"required": [
"count"
],
"properties": {
"count": {
"type": "number",
"description": "Number of items, 1 to 200"
},
"pattern": {
"enum": [
"linear",
"ease-out",
"ease-in",
"center-out",
"edge-in",
"scattered"
],
"type": "string",
"description": "Delay pattern"
},
"step_ms": {
"type": "number",
"description": "Gap between items in ms (default 50)"
},
"budget_ms": {
"type": "number",
"description": "Max total sequence time (default 600)"
},
"duration_ms": {
"type": "number",
"description": "Each item's duration in ms"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}review_animation_principles — Animation principles review
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.
{
"type": "object",
"required": [
"description"
],
"properties": {
"purpose": {
"enum": [
"ui",
"marketing",
"illustration"
],
"type": "string",
"description": "ui, marketing or illustration"
},
"description": {
"type": "string",
"description": "Describe the animation: what moves, easing, timing, purpose"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}lint_lottie_json — Lottie JSON lint
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.
{
"type": "object",
"required": [
"json"
],
"properties": {
"json": {
"type": "string",
"description": "Lottie JSON text"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}lint_email_html — Email HTML lint
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.
{
"type": "object",
"required": [
"html"
],
"properties": {
"html": {
"type": "string",
"description": "The email HTML"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}check_email_preheader — Email preheader check
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.
{
"type": "object",
"properties": {
"html": {
"type": "string",
"description": "Email HTML (or leave blank and pass preheader)"
},
"subject": {
"type": "string",
"description": "Subject line, to compare"
},
"preheader": {
"type": "string",
"description": "Preheader text, if not passing HTML"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}check_email_dark_mode — Email dark mode check
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.
{
"type": "object",
"required": [
"html"
],
"properties": {
"html": {
"type": "string",
"description": "The email HTML"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}check_email_accessibility — Email accessibility check
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.
{
"type": "object",
"required": [
"html"
],
"properties": {
"html": {
"type": "string",
"description": "The email HTML"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}check_email_subject — Email subject line check
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).
{
"type": "object",
"required": [
"subject"
],
"properties": {
"subject": {
"type": "string",
"description": "The subject line"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}calc_print_spec — Print spec calculator
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.
{
"type": "object",
"required": [
"trim_width",
"trim_height"
],
"properties": {
"safe": {
"type": "number",
"description": "Safe margin in the same unit (default 5 mm)"
},
"unit": {
"enum": [
"mm",
"cm",
"in",
"pt"
],
"type": "string",
"description": "Unit"
},
"bleed": {
"type": "number",
"description": "Bleed in the same unit (default 3 mm)"
},
"pages": {
"type": "number",
"description": "Printed page count (books)"
},
"binding": {
"enum": [
"perfect",
"saddle",
"none"
],
"type": "string",
"description": "Binding"
},
"caliper": {
"type": "number",
"description": "Thickness of one sheet"
},
"trim_width": {
"type": "number",
"description": "Finished width"
},
"trim_height": {
"type": "number",
"description": "Finished height"
},
"caliper_unit": {
"enum": [
"microns",
"mm",
"mil",
"in"
],
"type": "string",
"description": "Caliper unit"
},
"spine_extra_mm": {
"type": "number",
"description": "Extra spine allowance in mm"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}calc_print_resolution — DPI calculator
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.
{
"type": "object",
"required": [
"width",
"height"
],
"properties": {
"unit": {
"enum": [
"mm",
"cm",
"in"
],
"type": "string",
"description": "Size unit"
},
"width": {
"type": "number",
"description": "Print width"
},
"height": {
"type": "number",
"description": "Print height"
},
"pixels_h": {
"type": "number",
"description": "Image height in pixels"
},
"pixels_w": {
"type": "number",
"description": "Image width in pixels you have"
},
"distance_unit": {
"enum": [
"cm",
"in",
"m"
],
"type": "string",
"description": "Distance unit"
},
"viewing_distance": {
"type": "number",
"description": "Viewing distance (default: handheld, 300 ppi)"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}check_colour_mode — Color mode check
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.
{
"type": "object",
"required": [
"colors"
],
"properties": {
"stock": {
"enum": [
"coated",
"uncoated",
"newsprint"
],
"type": "string",
"description": "Paper stock"
},
"colors": {
"type": "string",
"description": "One color per line"
},
"smallest_text_pt": {
"type": "number",
"description": "Smallest black text in pt"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}convert_paper_size — Paper size converter
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.
{
"type": "object",
"properties": {
"size": {
"type": "string",
"description": "Standard name, e.g. A4, Letter, B5, C6"
},
"unit": {
"enum": [
"mm",
"cm",
"in",
"pt"
],
"type": "string",
"description": "Unit for custom size"
},
"width": {
"type": "number",
"description": "Custom width (if no size)"
},
"height": {
"type": "number",
"description": "Custom height"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}plan_imposition — Imposition planner
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.
{
"type": "object",
"required": [
"pages"
],
"properties": {
"pages": {
"type": "number",
"description": "Page count (total, including covers if self-cover)"
},
"binding": {
"enum": [
"saddle",
"perfect",
"sewn"
],
"type": "string",
"description": "Binding"
},
"signature": {
"enum": [
"4",
"8",
"16",
"32",
"64"
],
"type": "string",
"description": "Pages per signature (perfect or sewn)"
},
"caliper_microns": {
"type": "number",
"description": "Thickness of one sheet in microns (for creep)"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}print_file_checklist — Print file checklist
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.
{
"type": "object",
"properties": {
"colour": {
"enum": [
"cmyk",
"cmyk-spot",
"black-white"
],
"type": "string",
"description": "Color setup"
},
"product": {
"enum": [
"flyer",
"brochure",
"book-perfect",
"book-saddle",
"business-card",
"poster",
"packaging",
"large-format"
],
"type": "string",
"description": "Product"
},
"finishes": {
"type": "string",
"description": "Comma-separated finishes"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}approx_print_colour — Screen and print color approximation
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.
{
"type": "object",
"required": [
"value"
],
"properties": {
"value": {
"type": "string",
"description": "Hex, rgb() or cmyk()"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}logo_size_rules — Logo size rules
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.
{
"type": "object",
"required": [
"width",
"height"
],
"properties": {
"kind": {
"enum": [
"wordmark",
"lockup",
"symbol",
"monogram"
],
"type": "string",
"description": "wordmark, lockup, symbol or monogram"
},
"unit": {
"type": "string",
"description": "Unit of width, height and letterform, e.g. px, mm. Default px"
},
"width": {
"oneOf": [
{
"type": "number"
},
{
"type": "string"
}
],
"description": "Logo artwork width"
},
"height": {
"oneOf": [
{
"type": "number"
},
{
"type": "string"
}
],
"description": "Logo artwork height"
},
"letterform": {
"oneOf": [
{
"type": "number"
},
{
"type": "string"
}
],
"description": "Height of a reference letterform (capital or x-height), same unit"
},
"clearSpaceMultiple": {
"oneOf": [
{
"type": "number"
},
{
"type": "string"
}
],
"description": "Clear space as a multiple of the letterform, 0.25 to 4. Default 1"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}logo_contrast_variants — Logo colorways
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.
{
"type": "object",
"required": [
"colours"
],
"properties": {
"logo": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "Colors used inside the full-color logo (default: the primary color)"
},
"colours": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "Brand colors, hex/rgb/hsl, optionally named. First is primary."
},
"backgrounds": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "Backgrounds to test (default: brand colors, white, black)"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}brand_voice_consistency — Voice consistency
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.
{
"type": "object",
"required": [
"samples"
],
"properties": {
"rules": {
"oneOf": [
{
"type": "string"
},
{
"type": "object"
},
{
"type": "array",
"items": {}
}
],
"description": "Voice rules: lines of text, or a JSON object/array"
},
"samples": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "The pieces of copy to compare (2 to 40)"
},
"bannedWords": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "Extra banned words or phrases"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}naming_check — Naming check
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.
{
"type": "object",
"required": [
"names"
],
"properties": {
"tld": {
"type": "string",
"description": "Top-level domain for the domain form, default com"
},
"names": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "Candidate names (1 to 30)"
},
"existing": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "Names to compare against (competitors, existing brands)"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}tagline_review — Tagline review
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.
{
"type": "object",
"required": [
"taglines"
],
"properties": {
"brand": {
"type": "string",
"description": "Brand name"
},
"cliches": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "Extra phrases to flag"
},
"taglines": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "Taglines, one per line (1 to 25)"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}brand_architecture_planner — Brand architecture
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.
{
"type": "object",
"required": [
"products"
],
"properties": {
"company": {
"type": "string",
"description": "Parent company or master brand name"
},
"products": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {}
}
],
"description": "Products, one per line as 'Name | key=value | ...', or an array of objects"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}colour_palette_brief_check — Palette against brief
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.
{
"type": "object",
"required": [
"palette"
],
"properties": {
"brief": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "Brief words, comma or line separated"
},
"palette": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "Palette colors, optionally named, up to 16"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}review_microcopy — Microcopy review
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.
{
"type": "object",
"required": [
"items"
],
"properties": {
"items": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "Strings, one per line, with a type prefix such as 'button: Save changes'"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}error_state_writer_template — Error state skeleton
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.
{
"type": "object",
"required": [
"problem"
],
"properties": {
"fix": {
"type": "string",
"description": "What the reader can do next"
},
"cause": {
"type": "string",
"description": "Why, only if the reader can use it"
},
"where": {
"type": "string",
"description": "Field or page"
},
"contact": {
"type": "string",
"description": "Support channel, e.g. support"
},
"problem": {
"type": "string",
"description": "What happened, in plain words"
},
"canRetry": {
"type": "string",
"description": "yes if trying again can work"
},
"severity": {
"enum": [
"blocking",
"recoverable",
"warning"
],
"type": "string",
"description": "blocking, recoverable or warning"
},
"dataSaved": {
"type": "string",
"description": "yes if the user's work is safe"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}content_hierarchy_check — Content hierarchy
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.
{
"type": "object",
"required": [
"text"
],
"properties": {
"text": {
"type": "string",
"description": "The content, with # headings"
},
"keyTerms": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "Terms the reader must meet early"
},
"firstWords": {
"oneOf": [
{
"type": "number"
},
{
"type": "string"
}
],
"description": "How many opening words count as early, 10 to 200. Default 40"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}plain_language_check — Plain language
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.
{
"type": "object",
"required": [
"text"
],
"properties": {
"text": {
"type": "string",
"description": "The text to check"
},
"jargon": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "Extra jargon words to flag"
},
"targetGrade": {
"oneOf": [
{
"type": "number"
},
{
"type": "string"
}
],
"description": "Target reading grade, 3 to 16. Default 8"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}localisation_readiness — Localisation readiness
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.
{
"type": "object",
"required": [
"strings"
],
"properties": {
"strings": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "Source strings, one per line"
},
"maxChars": {
"oneOf": [
{
"type": "number"
},
{
"type": "string"
}
],
"description": "Character limit applied to every string"
},
"expansion": {
"oneOf": [
{
"type": "string"
},
{
"type": "object"
}
],
"description": "Expansion factors by language, e.g. 'de=1.3, fr=1.25' or {de: 1.3}"
},
"languages": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "Language codes to project, default all in the table"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}button_label_consistency — Button label consistency
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.
{
"type": "object",
"required": [
"labels"
],
"properties": {
"groups": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "Own synonym sets, one per line, comma separated"
},
"labels": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "Labels, one per line, repeated per occurrence"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}notification_copy_check — Notification copy
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.
{
"type": "object",
"required": [
"notifications"
],
"properties": {
"channel": {
"enum": [
"push",
"email",
"inapp",
"sms"
],
"type": "string",
"description": "Default channel: push, email, inapp or sms"
},
"notifications": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "One per line: 'title | body', optional channel prefix"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}nav_depth_check — Navigation depth
Analyze a navigation tree. Give `tree` as indented text (2 or 4 spaces or tabs, bullets optional, or 'A > B > C' paths) or JSON (nested {label, children} objects, arrays or a key-value map). Optionally `maxDepth` (default 4), `maxBreadth` (default 9) and `pages` (pages or labels that should be reachable, to find orphans). Returns node and leaf counts, depth, nodes and average children per level, the widest branch, items deeper than the limit, branches wider than the limit, one-child branches, naming collisions (siblings with the same name, the same name in different branches, a child repeating its parent), and orphans. Structural checks only; limits are conventions and there is no magic number.
{
"type": "object",
"required": [
"tree"
],
"properties": {
"tree": {
"oneOf": [
{
"type": "string"
},
{
"type": "object"
},
{
"type": "array",
"items": {}
}
],
"description": "Indented text, 'A > B' paths, or JSON"
},
"pages": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "Pages or labels that should appear in the tree"
},
"maxDepth": {
"oneOf": [
{
"type": "number"
},
{
"type": "string"
}
],
"description": "Deepest acceptable level, default 4"
},
"maxBreadth": {
"oneOf": [
{
"type": "number"
},
{
"type": "string"
}
],
"description": "Most items per level, default 9"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}label_clarity_check — Label clarity
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.
{
"type": "object",
"required": [
"labels"
],
"properties": {
"labels": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "Labels, one per line or comma separated"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}url_structure_review — URL structure
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.
{
"type": "object",
"required": [
"urls"
],
"properties": {
"urls": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "URLs or paths, one per line (up to 500)"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}taxonomy_overlap — Taxonomy overlap
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.
{
"type": "object",
"properties": {
"tags": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "Tags, one per line, optionally 'tag (count)'"
},
"terms": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "A single list when you do not separate tags and categories"
},
"categories": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "Categories, one per line, optionally 'category (count)'"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}tree_test_scorer — Tree test scorer
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.
{
"type": "object",
"required": [
"results"
],
"properties": {
"results": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {}
}
],
"description": "CSV text (or an array of row objects) with columns task, success, direct, first_click, time"
},
"expectedFirstClicks": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "Lines like 'Task name = Label, Label'"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}sitemap_to_outline — Sitemap to outline
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.
{
"type": "object",
"required": [
"input"
],
"properties": {
"input": {
"oneOf": [
{
"type": "string"
},
{
"type": "array",
"items": {
"type": "string"
}
}
],
"description": "URLs or paths, one per line, or an indented tree"
},
"format": {
"enum": [
"numbered",
"markdown",
"indent"
],
"type": "string",
"description": "numbered (default), markdown or indent"
}
}
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}cognitive_load_check — Cognitive load check
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.
{
"type": "object",
"required": [
"content"
],
"properties": {
"content": {
"type": "string",
"description": "HTML of the screen, or plain text of its copy. Up to 100,000 characters on the free tier."
}
},
"additionalProperties": false
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}check_reading_order — Reading order check
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.
{
"type": "object",
"required": [
"source"
],
"properties": {
"source": {
"type": "string",
"description": "HTML with style blocks, or CSS."
}
},
"additionalProperties": false
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}plan_focus_order — Focus order plan
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.
{
"type": "object",
"required": [
"markup"
],
"properties": {
"markup": {
"type": "string",
"description": "HTML of the page or component."
}
},
"additionalProperties": false
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}check_keyboard_shortcuts — Keyboard shortcut conflicts
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.
{
"type": "object",
"required": [
"shortcuts"
],
"properties": {
"platform": {
"enum": [
"any",
"mac",
"windows"
],
"type": "string",
"description": "Platform to judge against. Default any."
},
"shortcuts": {
"type": "string",
"description": "One shortcut per line, such as `Cmd+K: Open search`."
}
},
"additionalProperties": false
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}check_input_modality — Input modality check
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.
{
"type": "object",
"required": [
"source"
],
"properties": {
"source": {
"type": "string",
"description": "HTML, CSS and script text to scan."
}
},
"additionalProperties": false
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}check_rtl_readiness — RTL readiness
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.
{
"type": "object",
"required": [
"source"
],
"properties": {
"source": {
"type": "string",
"description": "HTML with style blocks, or CSS."
}
},
"additionalProperties": false
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}check_font_coverage — Font coverage check
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.
{
"type": "object",
"required": [
"text"
],
"properties": {
"text": {
"type": "string",
"description": "Sample copy in every language you ship."
},
"fonts": {
"type": "string",
"description": "Comma-separated font-family list, e.g. `Inter, Noto Sans JP, sans-serif`."
}
},
"additionalProperties": false
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}review_date_number_formats — Date and number format review
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.
{
"type": "object",
"required": [
"text"
],
"properties": {
"text": {
"type": "string",
"description": "UI copy to scan."
},
"locales": {
"type": "string",
"description": "Comma-separated BCP 47 tags. Default is 13 common locales."
},
"currency": {
"type": "string",
"description": "ISO 4217 currency code for the amount sample. Default USD."
}
},
"additionalProperties": false
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}plan_text_expansion — Text expansion planner
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.
{
"type": "object",
"required": [
"strings"
],
"properties": {
"strings": {
"type": "string",
"description": "One UI string per line."
},
"maxChars": {
"type": "number",
"description": "Character capacity of the container, optional."
},
"languages": {
"type": "string",
"description": "Comma-separated language codes."
}
},
"additionalProperties": false
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}check_name_fields — Name field check
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.
{
"type": "object",
"required": [
"markup"
],
"properties": {
"markup": {
"type": "string",
"description": "Form HTML, optionally with script."
}
},
"additionalProperties": false
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}check_cjk_line_breaking — CJK line breaking check
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.
{
"type": "object",
"required": [
"source"
],
"properties": {
"source": {
"type": "string",
"description": "HTML with styles, or CSS plus sample text."
}
},
"additionalProperties": false
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}review_locale_picker — Locale picker review
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.
{
"type": "object",
"required": [
"locales"
],
"properties": {
"locales": {
"type": "string",
"description": "Switcher markup, or lines like `de: Deutsch`."
}
},
"additionalProperties": false
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}check_handoff_spec — Handoff spec check
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.
{
"type": "object",
"required": [
"spec"
],
"properties": {
"spec": {
"type": "string",
"description": "JSON array of components, or one component per line separated by pipes."
}
},
"additionalProperties": false
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}check_naming_conventions — Naming convention check
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.
{
"type": "object",
"required": [
"names"
],
"properties": {
"names": {
"type": "string",
"description": "One layer, component or token name per line."
}
},
"additionalProperties": false
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}plan_asset_exports — Asset export planner
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.
{
"type": "object",
"required": [
"assets"
],
"properties": {
"assets": {
"type": "string",
"description": "Lines like `name | 24x24 | icon | web, ios`, or a JSON array."
}
},
"additionalProperties": false
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}plan_responsive_images — Responsive image planner
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.
{
"type": "object",
"required": [
"breakpoints"
],
"properties": {
"dprs": {
"type": "string",
"description": "Comma-separated DPRs, default `1,2`."
},
"aspect": {
"type": "string",
"description": "Width:height such as 16:9."
},
"format": {
"enum": [
"jpeg",
"webp",
"avif",
"png"
],
"type": "string"
},
"content": {
"enum": [
"photo",
"graphic",
"noisy"
],
"type": "string"
},
"aboveFold": {
"type": "boolean"
},
"urlPattern": {
"type": "string",
"description": "URL with {w}, e.g. /img/hero-{w}.webp"
},
"breakpoints": {
"type": "string",
"description": "Pairs like `0:100vw, 768:50vw, 1200:600px`."
},
"maxViewport": {
"type": "number"
},
"sourceWidth": {
"type": "number",
"description": "Original image width in pixels."
}
},
"additionalProperties": false
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}audit_icon_set — Icon set audit
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.
{
"type": "object",
"required": [
"icons"
],
"properties": {
"icons": {
"type": "string",
"description": "Markup with several <svg> elements."
}
},
"additionalProperties": false
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}check_svg_bloat — SVG bloat check
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.
{
"type": "object",
"required": [
"svg"
],
"properties": {
"svg": {
"type": "string",
"description": "The SVG source."
}
},
"additionalProperties": false
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}write_design_changelog — Design changelog
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.
{
"type": "object",
"required": [
"before",
"after"
],
"properties": {
"after": {
"type": "string",
"description": "The later list."
},
"title": {
"type": "string",
"description": "Optional heading."
},
"before": {
"type": "string",
"description": "The earlier list."
},
"version": {
"type": "string",
"description": "Optional version label."
}
},
"additionalProperties": false
}{
"readOnlyHint": true,
"openWorldHint": false,
"destructiveHint": false
}Prompts
23 advertised
getting_started — Getting started: what can this server do for me?
Explains the server and suggests the three best first tasks for what you have (a Figma link, a live URL, some copy, a research plan, an event list).
- have
- What you have in front of you: a Figma link, a live URL, copy, a research plan, an event list, or nothing yet
critique — Design critique for the stage the work is in
A structured critique of a design, framed by its stage (concept to shipped), ending in observations, impacts and a short list of changes. Refuses feedback that belongs to a later stage.
- design
- Figma link, screenshot, or a description of the design (required)
- stage
- concept, wireframe, visual, prototype, build or shipped (required)
- goal
- What the design has to achieve and for whom
- focus
- What you want feedback on, and what you do not
heuristic_evaluation — Nielsen heuristic evaluation of a flow
Walks one task through a flow and records findings against Nielsen's ten heuristics with 0 to 4 severity, using the worksheet tool for signals. You do the judging.
- flow
- Figma link, URL, screenshots or a description of the flow (required)
- task
- The one task to evaluate, in the user's words (required)
- audience
- Who is doing the task
accessibility_review — Accessibility review (WCAG 2.2)
Reviews a Figma frame, a live page or a description against WCAG 2.2 using exact contrast maths and a markup audit, and says what still needs a human check.
- target
- Figma link, live URL, screenshots or HTML (required)
- level
- AA (default) or AAA
- focus
- A flow or component to prioritize
microcopy_review — UX writing and microcopy review
Reviews buttons, errors, empty states and other interface text for clarity, tone and consistency, and removes the AI-writing tells.
- copy
- The strings, or a Figma link to pull text from (required)
- voice
- Brand voice in a few words, if there is one
- audience
- Who reads it, and in what state of mind
slop_review — AI design and writing slop review
Finds what looks generated in a live page or a design (gradients, default fonts, eyebrows, card grids, stock copy) and says what to do instead.
- target
- Live URL, Figma link, screenshots, or copy (required)
research_plan — User research plan and interview guide
Turns a decision and a question into a research plan, picks the method, writes a screener and an interview or test guide, and lints the questions.
- decision
- The decision this research will inform (required)
- questions
- What you need to learn
- audience
- Who you need to hear from
- constraints
- Time, budget, access
feedback_synthesis — Synthesise feedback into themes and decisions
Turns a pile of feedback (interviews, tickets, survey comments, critique notes) into evidence-backed themes, severity and next actions.
- feedback
- The raw feedback, pasted or described (required)
- goal
- The question you are trying to answer
tracking_plan — Tracking plan for a design or product
Turns a flow or a product into an analytics tracking plan with named events, properties, funnels and the questions each answers, then lints it.
- product
- The product or flow, or a Figma link (required)
- questions
- The questions the team wants analytics to answer
- type
- saas, ecommerce, marketplace, content or mobile
brief_to_ui — Brief a model to design UI without the slop
Turns a product idea into a design brief a model can build from: point of view, type, color, layout, content and constraints, so the result is not the generic template.
- idea
- What is being designed, for whom, and why (required)
- references
- Sites or work you admire, and what you admire about them
- stack
- Framework or tool the result will be built in
- tool
- The generator you will paste it into: Claude, Figma Make, v0, Stitch, Lovable or other
handoff_spec — Design handoff spec for engineers
Produces a handoff document from a Figma frame or a design: behavior, states, tokens, content rules, accessibility, edge cases and acceptance criteria.
- design
- Figma link or description of what is being handed off (required)
- stack
- Framework and component library used
token_audit — Design token and color audit
Checks color, type and spacing tokens for naming, duplication, scale discipline and contrast, using the exact values from the file.
- source
- Figma link to a file with variables, or the tokens pasted as CSS variables or JSON (required)
design_system_audit — Design system audit chain
A full design system audit across foundations, tokens, components, accessibility, adoption and governance, with a scorecard and a 30-60-90 day plan.
- system
- Figma library link, repo, or description of the system (required)
- products
- The products that consume it
design_qa — Design QA: build against the spec
Compares a built page or screenshots to the Figma design and reports differences that matter to people, with measured values and an accessibility check.
- design
- Figma link for the intended design (required)
- build
- Live URL or screenshots of the build (required)
- tolerance
- Pixel tolerance agreed with engineering, default 2px
art_direction_brief — Art direction brief for AI image generation
Writes image prompts and a style guide that produce a coherent set of AI-generated images with a point of view, avoiding the stock-illustration and glowing-blob look.
- project
- What the images are for (required)
- mood
- Feel, references, what to avoid
- count
- How many images you need
stakeholder_presentation — Stakeholder design presentation
Builds the story for presenting design work to stakeholders: the decision, the evidence, the options, and the ask, with the objections to expect.
- work
- The design work and the decision needed (required)
- audience
- Who is in the room and what they care about
- minutes
- Time available
industry_playbook — Industry playbook review (Pro)
Reviews a design against a playbook for a specific product type: e-commerce checkout, SaaS onboarding, forms, dashboards or mobile. Requires Pro.
- industry
- ecommerce-checkout, saas-onboarding, forms, dashboards or mobile (required)
- design
- Figma link, URL or description (required)
start_here — Start here: what do you want to do?
The router. Asks what you have and what you want, then points you to the right tool or prompt. Same as getting_started.
- have
- What you have, or what you want to do
troubleshoot — Fix my setup: server, auth, Figma, limits
Walks through connection and setup problems with the doctor tool and the troubleshooting tree. Use when something is connected but not working, or you hit 401, 403 or limits.
- symptom
- What is going wrong, in your words, with any error text
- client
- Claude Desktop, claude.ai, Claude Code, Cursor, VS Code, Codex or ChatGPT
- figma_link
- A Figma link you are trying to use
design_md — Create or check a DESIGN.md
Interviews you or reads an existing site or Figma file, then writes a DESIGN.md (the context file models read before building) and checks it.
- source
- A live URL, a Figma link, or a description of the product and brand
- existing
- An existing DESIGN.md to check and improve
critique_compare — Compare two designs honestly
Compares two options or a before and after against a goal, forcing a pick, real problems in both, and evidence. Counters the tendency of models to praise whatever they see.
- option_a
- Figma link, URL, screenshot or description of the first design (required)
- option_b
- Same for the second design (required)
- goal
- What the design must achieve, for whom (required)
build_a_skill — Build a skill: make your AI follow your rules
Interviews you about what your assistant should do differently (naming, states, tokens, voice, things it keeps getting wrong), then writes an Agent Skill: SKILL.md with a description tuned to trigger, two test prompts, and install steps for your tool.
- goal
- What the assistant should do differently when this skill is on, in one or two sentences (required)
- trigger
- The words a person on your team actually says when they want this
- good_example
- An output you were happy with, pasted or described
- bad_example
- An output you were unhappy with, and what was wrong
- rules
- Rules it must never break: naming, brand voice, legal lines, things it must ask before doing
- tool
- Claude Code, Claude.ai, Claude Desktop, Figma Make, Figma agent, Cursor, Copilot, Codex or other
microcopy_write — Write empty states, errors and microcopy
Writes the small text a product needs (empty states, errors, confirmations, tooltips, onboarding hints) in the product's voice, then checks it.
- screens
- The screens or situations that need copy, or a Figma link (required)
- voice
- Voice in a few words, or an example line
- audience
- Who reads it and how they feel at that moment
Resources
15 advertised
nielsen-heuristics — Nielsen's ten heuristics and severity scale
How to run a heuristic evaluation: the ten heuristics with what to look for, the 0 to 4 severity scale, and common mistakes.
designers://reference/nielsen-heuristicswcag-22-quick-reference — WCAG 2.2 quick reference by criterion
Every A and AA criterion in plain words with how to check it, including the 2.2 additions, and what automated tools miss.
designers://reference/wcag-22-quick-referencecritique-rubric — Critique rubric by stage
What to ask and what to refuse at each stage from concept to shipped, plus facilitator moves.
designers://reference/critique-rubricslop-tells — Slop tells: design and writing
A catalog of what generated design and writing share, and what to do instead.
designers://reference/slop-tellstracking-plan-naming — Tracking plan naming guide
How to name events and properties, the standard properties, funnels worth instrumenting, and the designer's part.
designers://reference/tracking-plan-namingfigma-mcp-workflow — Using a Figma link with these tools
How to read a design with the Figma MCP, then hand exact values to the checkers and report.
designers://reference/figma-mcp-workflowresearch-methods-selector — Choosing a research method
Which method answers which question, recruiting, interview technique, synthesis and common failures.
designers://reference/research-methods-selectordesign-md-template — DESIGN.md template
A fill-in template for the file that tells a model how your product looks and sounds, with the sections a model needs and examples of specific values.
designers://templates/design-mdtroubleshooting — Troubleshooting: connecting, auth, limits
The decision tree for setup problems: connected but nothing happens, local versus remote, 401 and 403, limits, tools not triggering, Figma links.
designers://reference/troubleshootingplaybook-ecommerce-checkout — Playbook: e-commerce checkout (Pro)
Step-by-step review of a checkout with severity-ready checks and metrics. Requires Pro.
designers://playbooks/ecommerce-checkoutplaybook-saas-onboarding — Playbook: SaaS onboarding (Pro)
Review onboarding from the activation moment backwards. Requires Pro.
designers://playbooks/saas-onboardingplaybook-forms — Playbook: forms (Pro)
Structure, inputs, validation, accessibility and measurement for forms. Requires Pro.
designers://playbooks/formsplaybook-dashboards — Playbook: dashboards (Pro)
Review a dashboard by the decisions it supports. Requires Pro.
designers://playbooks/dashboardsplaybook-mobile — Playbook: mobile apps (Pro)
Navigation, touch, interruptions, permissions, offline and accessibility for mobile. Requires Pro.
designers://playbooks/mobiledesign-system-audit-checklist — Design system audit checklist
Six-part audit of foundations, tokens, components, usage, governance and output format.
designers://reference/design-system-audit-checklist30-day availability
Aggregated from read-only remote checks; this is not a tool-execution or security guarantee.
- Successful checks
- 1 of 1 (100%)
- Average latency
- 341 ms
- 95th percentile latency
- 341 ms
Maintenance history
Public check and source-refresh events. Editorial and ownership records remain private.
- · probe · passed · 341 ms · metadata changed · 141 tool(s), 15 resource(s), 0 resource template(s), 23 prompt(s)
Connect from your client
Each snippet registers the same endpoint; pick the client you use.
Claude Code
claude mcp add --transport http designers-mcp https://designers.allthepossibles.com/mcpCodex
codex mcp add designers-mcp --url https://designers.allthepossibles.com/mcpCursor
{
"mcpServers": {
"designers-mcp": {
"url": "https://designers.allthepossibles.com/mcp"
}
}
}Cline
{
"mcpServers": {
"designers-mcp": {
"type": "streamableHttp",
"url": "https://designers.allthepossibles.com/mcp",
"disabled": false
}
}
}VS Code
{
"servers": {
"designers-mcp": {
"type": "http",
"url": "https://designers.allthepossibles.com/mcp"
}
}
}Gemini CLI
gemini mcp add --transport http designers-mcp https://designers.allthepossibles.com/mcpClaude Desktop
{
"mcpServers": {
"designers-mcp": {
"url": "https://designers.allthepossibles.com/mcp"
}
}
}Windsurf
{
"mcpServers": {
"designers-mcp": {
"serverUrl": "https://designers.allthepossibles.com/mcp"
}
}
}Let your agent find its tools
Find servers like Designers MCP from your agent. Add Koskamo once to search the index for endpoints, access requirements, and client setup. Public discovery needs no key.
Other design servers
Do you run Designers MCP?
Prove ownership with a DNS record, a well-known file, or your Official MCP Registry entry, and your edits publish immediately. Proofs are re-checked weekly; admins can still hide or remove a listing.