# A2UI Atomic Catalog (remote · a2uicatalog.ai)

500+ typed UI atoms an agent composes into real rendered interfaces. Free, no API key.

- Trust score: 67/100 (medium)
- Change this week: +3
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-21

## Components

- remote · `a2uicatalog.ai`: 67/100 (this document), [markdown](https://verifymcp.io/servers/ai-a2uicatalog-catalog/a2uicatalog.md), [page](https://verifymcp.io/servers/ai-a2uicatalog-catalog/a2uicatalog)

## Channel facts

- Endpoint: `https://a2uicatalog.ai/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `1.0.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-21.

- **Endpoint Security**: 46/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation check failed: no authorisation is required to call this server, and it exposes a tool marked destructive (unpublish_url).
  - HTTPS check failed: the endpoint is reachable over plaintext HTTP.
  - HSTS check failed: the Strict-Transport-Security header is absent.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 87/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (excellent).
  - Tool/resource definitions use about 17108 tokens (~80/item across 213 items; 40 tools + 173 resources), lean.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 37/100
  - Stability observed for 11 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
  - Structured output schemas are declared (60% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 4 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 42 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.
  - Supports UI / widget rendering.

## Install

### How do I install the A2UI Atomic Catalog MCP server?

A2UI Atomic Catalog is a hosted endpoint at https://a2uicatalog.ai/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add --transport http ai-a2uicatalog-catalog 'https://a2uicatalog.ai/mcp'
```

### Cursor

```json
{
  "mcpServers": {
    "ai-a2uicatalog-catalog": {
      "url": "https://a2uicatalog.ai/mcp"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "ai-a2uicatalog-catalog": {
      "type": "http",
      "url": "https://a2uicatalog.ai/mcp"
    }
  }
}
```

### Codex

```toml
[mcp_servers.ai-a2uicatalog-catalog]
url = "https://a2uicatalog.ai/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "ai-a2uicatalog-catalog": {
      "type": "remote",
      "url": "https://a2uicatalog.ai/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add ai-a2uicatalog-catalog --url 'https://a2uicatalog.ai/mcp' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  ai-a2uicatalog-catalog:
    url: "https://a2uicatalog.ai/mcp"
```

### Netclaw

```json
{
  "McpServers": {
    "ai-a2uicatalog-catalog": {
      "Transport": "http",
      "Url": "https://a2uicatalog.ai/mcp"
    }
  }
}
```

### Vellum

```bash
assistant mcp add ai-a2uicatalog-catalog -t streamable-http -u 'https://a2uicatalog.ai/mcp'
```

### Other

```json
{
  "mcpServers": {
    "ai-a2uicatalog-catalog": {
      "type": "http",
      "url": "https://a2uicatalog.ai/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-20 (score 67, +1)

No change was recorded against any check on this day. Stability & Change Management went from 30 to 33. That category is still filling its 30-day observation window: 9 days of observed history at the previous scan, 10 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-18 (score 66, +1)

No change was recorded against any check on this day. Stability & Change Management went from 23 to 27. That category is still filling its 30-day observation window: 7 days of observed history at the previous scan, 8 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-16 (score 65, +1)

No change was recorded against any check on this day. Stability & Change Management went from 17 to 20. That category is still filling its 30-day observation window: 5 days of observed history at the previous scan, 6 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-14 (score 64, 0)

- [security] Resource “a2ui_catalog_view” now points somewhere else: ui://a2uicatalog/view/156 → ui://a2uicatalog/view/157
- [security] Tool “find_atoms” rewrote its description, which is the text the model reads
- [security] Tool “get_atom_schema” rewrote its description, which is the text the model reads
- [functional] New resource “a2ui_catalog_view_v156”
- [cosmetic] “find_atoms” added an optional parameter “include_degraded”
- [cosmetic] “find_atoms” added an optional parameter “renderer”

### 2026-11-13 (score 64, +1)

No change was recorded against any check on this day. Stability & Change Management went from 7 to 10. That category is still filling its 30-day observation window: 2 days of observed history at the previous scan, 3 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-12 (score 63, +1)

- [security] Resource “a2ui_catalog_view” now points somewhere else: ui://a2uicatalog/view/155 → ui://a2uicatalog/view/156
- [functional] New resource “a2ui_catalog_view_v155”

### 2026-11-11 (score 62, 0)

- [functional improvement] Stability: unverified → 0.03

### 2026-11-10 (score 62)

First indexed and scored.

## MCP tools (40)

### `list_catalogs` (~48 tokens)

List every A2UI catalog with a when-to-use, so you can pick the extension catalogs a surface needs. The base catalog (a2ui-atoms-v1) is always resolved.

Output parameters:

- `baseCatalog` (string): URI of the base catalog, always resolved.
- `catalogs` (array): Every catalog with a when-to-use.

### `get_catalog` (~39 tokens)

Return one catalog's atoms (type + one-line description) so you know its vocabulary.

Input parameters:

- `catalog` (string, required): catalog slug or catalogId URI

Output parameters:

- `atoms` (array): The catalog's atoms, each with a type and one-line description.
- `catalogId` (string): Catalog URI.
- `slug` (string): Short slug.
- `title` (string): Title.
- `whenToUse` (string): When to pick it.

### `find_atoms` (~295 tokens)

Semantic search over the atom catalog: describe the UI piece you need in plain words and get the best-matching atoms, ranked best-first, each with a description and an example need. YOU choose from the list (the first entries are most likely, but check the descriptions), then call get_atom_schema for the one(s) you pick. Use this instead of scanning get_catalog when the vocabulary is large. Describe the need as a user would (e.g. "let clients choose grooming services and see the total price"), not by guessing an atom name. Pass `renderer` to keep only atoms that renderer draws as intended (status drawn or native); each result then carries renderer_status.

Input parameters:

- `include_degraded` (boolean): With renderer only: also keep atoms with status degraded (Flutter lowers them to Basic components, so they show but not as the atom intends). Default false.
- `k` (integer): How many candidates to return (default 10, max 50). If none fits, rephrase the need or ask for more.
- `need` (string, required): The UI piece you need, in plain words (one need per call)
- `renderer` (string): Optional renderer id: react, lit, angular, copilotkit, a2ui-vue, flutter or compose. Keeps only atoms whose measured status for it is drawn or native; atoms with no renderer data (not yet measured) a…

Output parameters:

- `also_named` (array): Unranked atoms whose names share a word with the request.
- `also_named_note` (string): Why also_named is listed.
- `atoms` (array): Candidates, best first.
- `confident` (boolean): True when the best score clears the rejection floor.
- `count` (integer): Number of ranked atoms returned.

### `get_atom_schema` (~224 tokens)

Return the PROP SHAPE (field names + what each field takes) for named atoms. get_catalog tells you an atom EXISTS; this tells you how to fill it. Call this before authoring any atom you have not used before — guessing prop names is the single most common cause of an atom rendering empty or wrong. Accepts several types at once, so a multi-atom surface resolves in one call. Each atom also carries `renderers`: renderer id -> measured status (web: drawn, drawn_with_differences, not_verified, not_supported, not_measured; flutter: native, degraded, not_supported, not_measured; compose: native, not_supported, not_measured). Only drawn and native mean it draws as intended; degraded = lowered to Basic components. renderers_matrix is the URL holding the reasons and evidence (atoms[<atom>][<renderer>]). Atoms not yet measured have no renderers.

Input parameters:

- `types` (array, required): Atom type names, e.g. ["weather_now","chartjs_bar"] (max 25)

Output parameters:

- `atoms` (object): Prop shapes keyed by atom type; each value has fields, description, surfaces and, when measured, renderers (renderer id -> status).
- `hint` (string): What to do about the unknown names.
- `renderers_matrix` (string): URL of the renderer matrix with the reasons and evidence behind each renderers status.
- `unknown` (array): Requested names that are not real atoms.

### `required_catalogs` (~65 tokens)

Given an A2UI payload, return the resolvable catalog URIs it needs (deterministic — pure function of the atoms).

Input parameters:

- `payload` (object, required): The A2UI payload to inspect: {title, theme, blocks:[...]} in the blocks dialect.

Output parameters:

- `required_catalogs` (array): Catalog URIs the payload needs (base catalog first).

### `build_multi_page_surface` (~168 tokens)

Build a multi-section A2UI app from raw title+content sections — you never estimate size or decide how to split; each section becomes its own independently-encoded page (no shared hub, so per-page size never grows with page count — genuinely unlimited sections). Returns the first page's `url` plus a `pages` array ([{heading, url}]) for every section — present that list to the user yourself (e.g. numbered links); pages do not cross-link to each other. Prefer this over make_surface_url for multi-section content.

Input parameters:

- `renderer_url` (string): Your deployed renderer /exec URL (optional; defaults to BYO)
- `sections` (array, required): Array of {heading, content} sections
- `title` (string, required): Hub page title

Output parameters:

- `clipboard` (object): Optional ready-made copy commands for the URL (linux, macos, windows) plus a note.
- `note` (string): How the pages relate.
- `page_count` (integer): Number of pages.
- `pages` (array): One entry per page, each with a url.
- `required_catalogs` (array): Catalog URIs the payload needs (base catalog first).
- `size` (object): Present when the URL is large: url_length, warning and recommendation.
- `url` (string): URL of the first page.

### `make_surface_url` (~482 tokens)

Render an A2UI payload in the CALLER'S OWN environment. Pass renderer_url (your deployed renderer /exec) and get a live URL + the catalogs it declares. Omit renderer_url to get the encoded fragment + BYO guidance. We host nothing and never see your content.

NEVER hand-write your own gzip/base64 encoding for the ?p= URL, in ANY language, even as a "just this once" fallback. This is the single most common cause of "could not decompress gzip" — a self-written encoder with one wrong flag (wrong wbits, standard vs. urlsafe base64, un-stripped padding) produces a broken URL at ANY size, not just large ones. Always call this tool again — never substitute your own implementation.

SIZING IS AUTOMATIC — you do not need to estimate, count characters, or decide whether to split. Call this tool ONCE with your FULL, unsplit payload. If it fits, you get back `url` (and nothing else to do). If it does not fit the real size ceiling, the tool SPLITS IT FOR YOU server-side (at natural heading boundaries) and returns `auto_split: true` plus a `pages` array of independent URLs — present that list to the user (e.g. as numbered links) instead of the single `url`. Never pre-split your content before the first call; always send everything in one call and let the response tell you what happened.

GRADUATE substantial surfaces with emit_deployment instead (no size limit at all) when you want a standing app rather than a shareable link.

IF A RENDER CHECK REPORTS "could not decompress gzip" / "Render error" / "invalid distance too far back" on a URL this tool returned: STOP. Do NOT call this tool again with the SAME unchanged payload — re-call it with the SAME payload once to confirm, and if it still fails, use emit_deployment instead. Never fall back to a hand-written encoding script.

Input parameters:

- `payload` (object, required): The A2UI payload to encode into a ?p= URL: {title, theme, blocks:[...]}. Send it whole; oversize payloads are split for you.
- `renderer_url` (string): your renderer /exec (BYO). Omit for fragment + guidance.

Output parameters:

- `auto_split` (boolean): True when the payload was split into pages.
- `clipboard` (object): Optional ready-made copy commands for the URL (linux, macos, windows) plus a note.
- `fragment` (string): The ?p= fragment to append to your own renderer (present when renderer_url was omitted).
- `note` (string): Guidance for the caller.
- `page_count` (integer): Number of pages when split.
- `pages` (array): One entry per page, each with a url.
- `required_catalogs` (array): Catalog URIs the payload needs (base catalog first).
- `size` (object): Present when the URL is large: url_length, warning and recommendation.
- `url` (string): Live renderer URL (present when renderer_url was given; the first page when split).

### `preview_url` (~133 tokens)

Quick DEMO render on the public renderer (ephemeral, nothing stored). Limited to 2 runs per client, then deploy your own renderer and use make_surface_url. Onboarding only — not the workflow. DATA-IN-URL: keep payloads SMALL (URL < ~2000 chars); large payloads make long URLs that get truncated (→ render errors). For substantial content GRADUATE with emit_deployment instead — no size limit.

Input parameters:

- `payload` (object, required): The A2UI payload to preview: {title, theme, blocks:[...]}. Keep it small (URL under about 2000 chars).

Output parameters:

- `clipboard` (object): Optional ready-made copy commands for the URL (linux, macos, windows) plus a note.
- `demo` (boolean): Always true: this is a demo render.
- `limitReached` (boolean): True when the per-client demo limit was hit; no link is returned then.
- `note` (string): Which link to use.
- `play_url` (string): Link to the a2uicatalog.ai playground (recommended to share).
- `required_catalogs` (array): Catalog URIs the payload needs (base catalog first).
- `size` (object): Present when the URL is large: url_length, warning and recommendation.
- `url` (string): Link on the public Apps Script renderer.

### `render_surface` (~258 tokens)

Render an A2UI payload INSIDE the chat as a live interactive view (MCP Apps hosts only — on other hosts this returns the payload as text). No URL, no size ceiling, nothing stored: the payload travels in the tool result and renders in the a2ui_catalog_view. Accepts the blocks dialect or a v1.0 createSurface envelope (templates + dataModel decode in the view). Prefer this over preview_url when the host supports MCP Apps.

If the user names one of the Workspace's own pre-built views — Wall Builder, profile, history, links, composer — call open_workspace(view: ...) instead of composing one here yourself; those are wired demos with their own state, not something to reconstruct block by block. And never invent a generic block type (there is no "text" or "button" atom) — call get_catalog / get_atom_schema for the real vocabulary first; an unrecognised type is caught and replaced with a visible notice rather than silently dropped, but the block still won't render as intended.

Input parameters:

- `payload` (object, required): The A2UI payload to render in the chat view: blocks dialect {title, theme, blocks:[...]} or a v1.0 createSurface envelope.

### `make_film` (~1169 tokens)

Make a short motion film (a social clip, launch teaser, quote card...) built by the A2UI Design Studio: you choose a template and supply the words; the studio builds the film. Use this instead of composing motion_timeline blocks yourself. It plays inline here and comes with a link that opens in the A2UI Studio app on Android, where the user can edit the text and export MP4 or GIF on the phone.

BEFORE CALLING, ask the user in one short message for what you do not know: what it is about (the hook line), any real numbers with their labels, the call to action, and where it will be posted (portrait 9:16 for LinkedIn/Instagram/stories, 16:9 for slides or YouTube, 1:1 for a quote card). Never invent statistics: with no real numbers, use scenes without a Numbers or Chart scene.

Templates (each a ready scene sequence; pass `scenes` to replace it):
launch: Product launch, Title, numbers, phone, call to action (16:9; scenes title > stats > device > cta)
data: Data story, Chart, numbers, steps (16:9; scenes title > chart > stats > steps)
agent: Agent demo, Chat, particle word, CTA (16:9; scenes chat > word > cta)
quote: Quote card, A quote and a name (1:1; scenes quote > cta)
hook: LinkedIn hook, Portrait: captions, numbers, CTA (9:16; scenes captions > stats > cta)
client: Client feature demo, Title, features that light up beside your pictures, CTA (16:9; scenes title > features > cta)
event: Event promo, Particle word, title, photo, CTA (16:9; scenes word > title > morph > cta)

Scene types and their fields (`fields` keys; text supports *word* for the accent colour; list fields take one item per line in the format the label gives):
title (Title): eyebrow = Eyebrow; headline = Headline (use *word* for accent); sub = Subline
stats (Numbers): kicker = Kicker; stats = Stats, one per line: value | label; roll = Number style
chart (Chart): heading = Heading; kind = Chart; data = Data, one per line: label value; unit = Unit
chat (Chat): heading = Heading; messages = Messages, alt…

Input parameters:

- `aspect` (string): Override the template aspect.
- `look` (string): Colour preset. Default: the template's.
- `pace` (string): Timing preset for scene length and transitions. Default: the template's.
- `scenes` (array): Scenes in order, replacing the template's. Omit to keep the template's scenes with its sample words.
- `template` (string, required): Starting template.
- `title` (string): Film title (also the file name when exported).

### `sketch_agent_start` (~132 tokens)

Start a real, live agent_sketchpad drawing: one Gemini call plans a complete picture as an ordered list of SVG strokes, the first stroke renders immediately, and the rest reveal as you call sketch_agent_poll again — a real multi-turn task, not a single one-shot render. MCP Apps hosts only (same as render_surface). Stateless server: the task is held in KV for 1 hour, not in this connection — keep the returned taskId and the next cursor to keep polling.

Input parameters:

- `subject` (string, required): What to draw, e.g. "a lighthouse at sunset". Max 150 characters.

### `sketch_agent_poll` (~118 tokens)

Continue a sketch_agent_start task: returns every stroke newer than the given cursor (an event log, not a snapshot — nothing is skipped regardless of poll timing) plus the next cursor, reveals the result in-chat the same way render_surface does, and reports whether the drawing is complete. Call again with the returned cursor until done is true.

Input parameters:

- `cursor` (integer, required): The cursor returned by the previous start/poll call. 0 to start from the beginning.
- `taskId` (string, required): The taskId returned by sketch_agent_start.

### `render_ping` (~72 tokens)

Diagnostic: render a tiny test view in-chat (MCP Apps hosts only). Proves view mounting works independent of the full catalog renderer. Echoes back whatever payload you pass.

Input parameters:

- `payload` (object): Any JSON object; it is echoed back as the result so you can see what the view received. Optional.

### `wasm_spike` (~86 tokens)

Diagnostic (MCP Apps hosts only): mounts a view that instantiates a tiny hand-assembled WebAssembly module, computes per-frame state in it, renders to canvas, and captures arrow-key input -- the same three ingredients a WASM game port would need. Answers whether THIS host permits WASM execution inside a ui:// View iframe; it proves nothing about any other host or sandbox.

### `diagram_studio` (~390 tokens)

Draw a diagram in-chat with the full Diagram Studio interface (MCP Apps hosts only; it opens fullscreen where the host allows it). YOU write the diagram; nothing is generated server-side and nothing is stored. PREFER `graph`: give vertices (id, label, type start|process|decision|database|cloud|end) and edges (source, target, optional label). The person then gets the whole studio: they can switch the same graph between Mermaid, D2, PlantUML and draw.io, flip its direction, zoom, copy the code, open it in the real draw.io editor with one click, and edit nodes and connections themselves (their edits come back to you). Use `syntax` with `source` instead only for diagrams a flow graph cannot express, drawn exactly as written: "mermaid" for sequence, class, state, ER, gantt and mind maps; "d2" for architecture diagrams with containers and nested boxes. Give exactly one of `graph` or `syntax` with `source`. Keep diagrams compact (the input schema states the limits). If the tool or the view reports a problem, fix it and call this tool again. On a host without MCP Apps support the diagram comes back as text.

Input parameters:

- `direction` (string): Graph layout direction: TB (top to bottom, default) or LR.
- `format` (string): Which format the view opens on. Default mermaid; mermaid and d2 draw a picture.
- `graph` (object): The diagram as a graph (preferred).
- `source` (string): Only with `syntax`: a complete diagram, drawn as written.
- `syntax` (string): Only with `source`: the language of that source.
- `theme` (string): Colours for the draw.io output. Default modern_indigo.
- `title` (string): Optional heading shown above the diagram.

### `amiga` (~124 tokens)

Open a real, cycle-exact Amiga 500 emulator in-chat (MCP Apps hosts only). Boots straight into AROS, a free open-source environment (no copyrighted Kickstart ROM involved), with a public-domain Amiga game already loaded and running. This is a fixed, self-contained retro-computing demo -- there is nothing to configure and no arguments to give it; call it when someone wants to see or play with a real emulated Amiga. On a host without MCP Apps support this says so as text; an emulator has no useful non-visual form.

### `distill_document` (~160 tokens)

Compile a training.md / roadmap markdown document into a live interactive A2UI app — DETERMINISTIC parser, no model involved. Fact sheet: input is MARKDOWN following the training-md contract (frontmatter id/domain/name/source/license + a # Steps section); the text transits to the catalog's stateless parser service for the duration of the call and is NOT stored; lint errors come back as a structured report (fix and re-call). On success the result IS the compiled surface — MCP Apps hosts paint it in the view; other hosts can pass the returned payload to preview_url for a link.

Input parameters:

- `domain` (string): parse contract to apply (default training)
- `markdown` (string, required): the full markdown document, frontmatter included

### `publish_url` (~281 tokens)

STORES the payload server-side and returns a SHORT shareable link. Opt-in only: requires acknowledge_storage=true — confirm with the user first that they accept operator-hosted storage (ONE WEEK retention on the public tier, revocable earlier via the returned delete_token; anyone with the link can view). target "play" (default) renders in the a2uicatalog playground by reference (no URL size ceiling); target "gas" makes the short link redirect to the public Apps Script renderer. For storage in the USER's own account use emit_deployment; for nothing-stored links use preview_url.

Input parameters:

- `acknowledge_storage` (boolean, required): MUST be true — affirms the user consented to server-side storage
- `alias` (string): optional vanity name for the link (/s/<alias>) — first-come, frees when the link expires
- `payload` (object, required): The A2UI payload to store and share: {title, theme, blocks:[...]}, up to 100 KB serialised.
- `target` (string): Where the short link opens: "play" (default) the a2uicatalog playground by reference, "gas" the public Apps Script renderer.
- `ttl_days` (number): OPERATOR-ONLY (authenticated requests): retention override; 0 = permanent. Public tier is fixed at one week.

Output parameters:

- `delete_token` (string): Pass to unpublish_url to revoke.
- `error` (string): Why nothing was stored (present when ok is false, e.g. daily limit).
- `note` (string): Retention and viewing notes.
- `ok` (boolean): True when the payload was stored.
- `short_url` (string): Short shareable link.
- `stored_until` (string): Expiry date (YYYY-MM-DD) or "permanent".
- `target` (string): "play" or "gas".

### `unpublish_url` (~78 tokens)

Delete a published short link before its TTL using the delete_token returned by publish_url.

Input parameters:

- `delete_token` (string, required): The delete_token that publish_url returned for this link.
- `id` (string, required): The published link id, or the full short URL (https://a2uicatalog.ai/s/<id>) returned by publish_url.

Output parameters:

- `data` (object): Result detail.
- `ok` (boolean): True when the link was deleted.

### `emit_deployment` (~143 tokens)

🎓 GRADUATE a tested surface into a dedicated, DEPLOYER-ONLY standing app in YOUR OWN Google Apps Script account. Returns a deterministic recipe (config files + clasp ops + least-privilege scopes derived from the atoms + verify) — you run it with your own clasp; nothing runs on our side, we hold no creds.

Input parameters:

- `app_name` (string): Name for the Apps Script project and its folder. Defaults to the payload title, else "A2UI App".
- `payload` (object, required): The tested A2UI payload to bake into the standing app as its home surface: {title, theme, blocks:[...]}.

Output parameters:

- `files` (object): File name to file content for the Apps Script project (HomeSurface.gs, appsscript.json).
- `inputs` (object): Resolved inputs.
- `note` (string): What the recipe does.
- `ops` (array): Ordered shell steps to build and deploy.
- `renderer_source` (object): Where to fetch the open renderer.
- `required_catalogs` (array): Catalog URIs the payload needs (base catalog first).
- `verify` (string): How to check the deployed app.

### `emit_training_runbook` (~147 tokens)

Build a multi-lesson training/course surface as ONE properly-linked page with real in-app tab navigation between lessons — prefer this over build_multi_page_surface for training/course content specifically: that tool produces N independent pages with NO links between them (you must present the list yourself); this tool produces one page where lessons are real, clickable tabs. Zero sizing/estimation judgment required — give it your lessons, it handles composition and navigation.

Input parameters:

- `lessons` (array, required): Array of {heading, content} lessons — each becomes its own tab
- `renderer_url` (string): Your deployed renderer /exec URL (optional; defaults to BYO)
- `title` (string, required): Course title

Output parameters:

- `clipboard` (object): Optional ready-made copy commands for the URL (linux, macos, windows) plus a note.
- `note` (string): How the tabs work.
- `payload` (object): The compiled A2UI v1.0 createSurface payload.
- `required_catalogs` (array): Catalog URIs the payload needs (base catalog first).
- `size` (object): Present when the URL is large: url_length, warning and recommendation.
- `url` (string): Renderer URL carrying the payload.

### `emit_runbook_surface` (~656 tokens)

Stamp your content through a DECLARED runbook — a pre-authored, judgment-free surface composition. You supply content only; the runbook supplies the composition (which atoms, how arranged, navigation). DISCOVERY: call with runbook_id only (no content) to get that runbook's input_contract + parsing_guide — shape your source data to the contract (parsing is your job as the consumer), then call again with `content`. Some runbooks also return `elicit` — questions to ASK THE USER before you fill the contract. Ask them; do not guess the answers.
ON SUCCESS YOU GET BOTH `payload` AND `url`, AND THEY ARE NOT THE SAME OFFER. `payload` is the compiled surface — pass it STRAIGHT to render_surface and the reading appears inline, in the conversation, where the reader already is. `url` is the shareable link, for later or for elsewhere. Default to rendering: handing back only a link makes the reader leave to see the thing they asked for. If the reading was too large to encode as a link you get `payload` and `url_unavailable` instead — that is a SUCCESS, so render it and say the link is missing.
Available stampable runbooks: (1) learning_hub — curriculum/revision study app: subject tabs, slide pills, timeline/drill/flashcards/quiz/takeaways/method interactions per slide, the full rich hub UI. Prefer this over emit_training_runbook for study/curriculum content — much richer output, still zero composition decisions. (2) article_playbook — a steered critical reading of SOMEONE ELSE'S article: source attribution bar, a hero mental-model card, then rungs down a rail. The reader picks a lens (explain, apply to their domain, challenge, situate in prior art) and says what they want it to look for; the rung progression is Toulmin (claim → grounds → warrant) so the analysis lands on the assumption a summary drops. Use it whenever asked to analyse, critique, tear down, or work out what an article means for a particular domain. You fetch and read the article yourself; nothing is retrieved ser…

Input parameters:

- `content` (object): Your content shaped to the runbook's input_contract. Omit to get the contract back instead of a URL.
- `renderer_url` (string): Your deployed renderer /exec URL (optional; defaults to the public demo renderer)
- `runbook_id` (string, required): Stampable runbook name. "learning_hub" = curriculum/study app from content you supply. "article_playbook" = a steered critical reading of someone else's article (you fetch and read it yourself; the r…
- `source` (object): The source the USER supplied (workspace surfaces pass this; you normally do not). {url?, text?}. Echoed back in the discovery response so you read THAT source rather than asking for it again. Ignored…

### `describe_playbook` (~117 tokens)

Explain a playbook to a HUMAN as a rendered surface: the frame it reads against, the lenses available, and the questions it will ask them. Compiled from the runbook declaration, so it costs nothing and cannot drift from what the stamper enforces. This is NOT emit_runbook_surface discovery — that returns a contract addressed to YOU. Use this when someone asks what a playbook does or how it works; pass the result to render_surface.

Input parameters:

- `runbook_id` (string, required): Which stampable runbook to describe.

### `open_workspace` (~308 tokens)

Open the A2UI Workspace — a rendered surface that IS the demo: each tool is introduced by the scenario it answers, then wired to run, then shows what it saved. This tool RENDERS ITSELF: its result carries the view, so call it alone and show the result — do NOT pass it on to render_surface, and do not describe the payload in prose. Call it when the user asks to open the workspace, wants to see what this connector can do, asks what is saved about them, or names one of its tools directly — e.g. "open the Wall Builder" means THIS tool with view: "wall_builder", not a separate tool named wall_builder. It shows a display name they chose, never their email.

Input parameters:

- `prompt` (string): Composer view only. Pre-fills the custom-prompt box with this text instead of the default example — used by a reopened generation's "Need to tweak?" action to carry its original prompt back into an e…
- `view` (string): Which screen to open — omit or "home" for the tool selector. The workspace UI navigates between these by calling this tool again with a different view (its own back button); you would normally only p…

### `get_profile` (~101 tokens)

Read the signed-in reader's saved profile and recent history. Call this BEFORE asking a runbook's `elicit` questions: if a domain or default lens is already saved, CONFIRM it ("reading as: a2ui, generative ui — change?") instead of asking from scratch. Returns available:false on the public endpoint, where there is no one to have a profile — that is the designed state, so degrade quietly and just ask the questions.

Output parameters:

- `available` (boolean): False when there is no signed-in reader or the store failed.
- `display_name_set` (boolean): Whether a display name is saved.
- `greeting` (string): Display name or "you".
- `note` (string): Guidance for the caller.
- `profile` (object): Saved profile fields.
- `reason` (string): Why it is unavailable.
- `recent_readings` (array): Most recent readings.
- `total_readings` (integer): Total saved readings.
- `user` (object): The reader {sub, email}.

### `save_profile` (~226 tokens)

Update the signed-in reader's profile. Only the keys you pass change; pass null to clear one. Save what the reader TOLD you, never what you inferred from one article — a profile that drifts on every reading is worse than no profile, because they stop being able to predict what it will do.

Input parameters:

- `concerns` (string): Standing things they always want pushed on, in their own words.
- `default_lens` (string): Opening posture when the reader does not name one: explain | apply | challenge | situate.
- `display_name` (string): What to call them in a rendered surface. Set this so a UI never has to show their email — the address is an identifier, not a greeting, and a shared screen should not leak it.
- `domains` (array): Areas of interest the apply lens transfers into, e.g. ["a2ui","generative ui"].
- `theme` (string): Reader's preferred UI theme. The Workspace saves this itself when its toggle is clicked — you would not normally set this from a chat turn.

Output parameters:

- `available` (boolean): False when there is no signed-in reader or the store failed.
- `note` (string): Guidance for the caller.
- `profile` (object): The profile after the update.
- `reason` (string): Why nothing was saved or the store is unavailable.
- `saved` (boolean): True when the profile changed.

### `save_reading` (~241 tokens)

Record a stamped surface in the reader's history so it can be compared and reopened later. Call it AFTER emit_runbook_surface, and PASS ITS `payload` — that stores the reading itself rather than a link to it. Silently no-ops when nobody is signed in.

Input parameters:

- `lens` (string): The lens the reading was made through (e.g. "explain"), so history can show it.
- `payload` (object): The compiled surface emit_runbook_surface returned (its `payload`). PASS IT. Without it the row is a link only, and a link depends on a renderer staying reachable — with it the reading is stored port…
- `runbook` (string, required): e.g. "article_playbook"
- `source_title` (string): The original article's headline, kept beside source_url.
- `source_url` (string): The original article, so history stays attributable.
- `title` (string): The ANALYSIS title (yours), not the source headline.
- `url` (string): The stamped surface url returned by emit_runbook_surface.

Output parameters:

- `available` (boolean): False when there is no signed-in reader or the store failed.
- `id` (string): Id of the stored reading.
- `note` (string): Guidance for the caller.
- `portable` (boolean): True when the payload was stored with it.
- `reason` (string): Why nothing was saved.
- `saved` (boolean): True when the row was stored.
- `warning` (string): Why the payload was not stored.

### `export_reading` (~169 tokens)

Export a kept reading as something that outlives this connector. format "html" returns ONE self-contained file — styles inlined, no network, opens in any browser years from now with nothing installed. "url" rebuilds a link against any renderer (yours by preference). "surface" returns the payload for repainting in place. "json" returns the decoded payload. Needs a reading saved WITH its payload; older link-only rows cannot be re-rendered and will say so.

Input parameters:

- `format` (string): Default html. "surface" returns the payload itself, for repainting in place.
- `id` (string): Reading id from list_readings. OMIT for the most recent one.
- `renderer_url` (string): For format "url": your own renderer /exec.

Output parameters:

- `available` (boolean): False when there is no signed-in reader or the store failed.
- `bytes` (integer): Size of the HTML.
- `exported` (boolean): True when an export was produced.
- `fonts_delocalised` (integer): Remote font faces removed.
- `format` (string): "html", "url", "json" or "surface".
- `html` (string): Self-contained HTML (format html).
- `note` (string): Guidance for the caller.
- `payload` (object): The stored payload (format json).
- `reason` (string): Why it is unavailable.
- `title` (string|null): Reading title.
- `url` (string): Rebuilt renderer URL (format url).

### `render_reading_to_slack` (~128 tokens)

Post a kept reading into Slack as real, native Block Kit — the continuity proof: generate here, save it, and the SAME content reopens in Slack, not a link back to a renderer. Requires the caller's Slack account to already be linked (`/a2ui link` in Slack) and only works on an authenticated connection — it posts to a real workspace using a shared bot token.

Input parameters:

- `channel` (string): Slack channel to post to. Default #general.
- `id` (string): Reading id from list_readings. OMIT for the most recent one.

Output parameters:

- `atoms_compiled` (integer): Atoms posted.
- `atoms_skipped` (array): Atom types with no Slack mapping.
- `available` (boolean): False without a signed-in reader.
- `degraded`
- `note` (string): Guidance for the caller.
- `ok` (boolean): True when the post succeeded.
- `posted_as` (string): Linked Slack account.
- `posted_to` (string): Slack channel.
- `reading_id` (string): Reading id.
- `reason` (string): Why nothing was posted.
- `slack_ts` (string): Slack message timestamp.
- `title` (string|null): Reading title.
- `truncated`

### `list_readings` (~89 tokens)

The reader's recent stamped surfaces, newest first — what makes "compare this to my last three teardowns" answerable at all. Optionally filter to one runbook. Returns available:false when nobody is signed in.

Input parameters:

- `limit` (integer): Default 20, max 100.
- `runbook` (string): Filter to one runbook, e.g. "article_playbook".

Output parameters:

- `available` (boolean): False when there is no signed-in reader or the store failed.
- `count` (integer): Number of readings returned.
- `note` (string): Guidance for the caller.
- `readings` (array): Saved readings, newest first.
- `reason` (string): Why it is unavailable.

### `delete_reading` (~112 tokens)

Permanently remove one or more of the reader's saved readings from their History. Takes an array so the Workspace's multi-select can delete a batch in one call rather than one round trip per row. Ids that don't exist (or belong to someone else's history) are silently skipped — the response's `deleted` count says how many rows actually went, never assume it equals the number of ids you sent.

Input parameters:

- `ids` (array, required): Reading ids from list_readings. A single-item array deletes one row.

Output parameters:

- `available` (boolean): False when there is no signed-in reader or the store failed.
- `deleted` (integer): Rows deleted.
- `note` (string): Guidance for the caller.
- `reason` (string): Why nothing was deleted.
- `requested` (integer): Ids requested.

### `read_article` (~251 tokens)

Have the catalog's own model (Gemini) read an article through the article_playbook runbook and KEEP the reading in the signed-in reader's history, in one call. For a client with no model of its own (the Android analyser app), or when the reader asks for a Gemini reading. If you can read the article yourself, prefer emit_runbook_surface + save_reading. Pass `text` when you already have the article (it is then the only source the reading may quote), else `url` and it is fetched server-side. Takes 20-60 s. Needs a signed-in reader; capped per reader per day.

Input parameters:

- `concerns` (string): What the reader wants the reading to look for or push back on.
- `domains` (string): For lens "apply": the reader's domains, comma-separated.
- `lens` (string): Default explain.
- `source_title` (string): The article's headline, kept with the reading for attribution.
- `text` (string): The article text, if the caller already fetched it. Truncated to 60000 chars.
- `url` (string, required): The article's public URL. Required: it is the attribution link.

Output parameters:

- `analysed_by` (string): Model that read the article.
- `note` (string): Set when the article text was truncated.
- `ok` (boolean): True when the reading was produced.
- `payload` (object): The stamped article_playbook surface.
- `reading_id` (string): Id of the saved reading.
- `reads_today` (integer): Reads used today by this reader.
- `retrieval` (string): How the text was obtained.
- `save_warning` (string): Why the reading was not saved.
- `url` (string): Renderer URL for the reading.

### `deck_schema` (~69 tokens)

List the slide layouts the PPTX renderer builds (title, bullets, stats, quote, table, media, cta), each field with its limits, the targets, the film-only scenes, and the A2UI atoms that have a slide recipe (payload_atoms). Read this before writing a deck.

### `deck_validate` (~266 tokens)

Check a deck (scene list or A2UI payload) without building it. Returns every error with its slide, field and exact limit, warnings (no speaker notes, no link) and, for a payload, which atoms have no slide recipe. Not rate-limited.

Input parameters:

- `deck`: A typed scene list: {"title","target","scenes":[{"type":"title|bullets|stats|quote|table|media|cta","f":{...fields...},"notes":"speaker notes"}]}. Same scene fields as make_film (eyebrow, headline, s…
- `payload`: An A2UI payload {"blocks":[{"type":"quote",...},...]}: each atom with a slide recipe becomes slides, others are listed under `unsupported`, never guessed. deck_schema lists the atoms. Give payload OR…
- `skip_film_only` (boolean): For a scene list that came from a film: leave out scenes with no slide layout (chart, chat, word, morph, captions, image) instead of treating them as errors.

### `deck_build` (~429 tokens)

Build a PowerPoint (.pptx) file from a scene list or an A2UI payload. Deterministic (same input, same bytes), nothing is stored or fetched, text is fitted with real font metrics and the file is linted (overlap, bounds, contrast, alt text). Returns the file as an embedded resource plus a report: errors, lint, warnings and unsupported atoms. Opens in PowerPoint and Google Slides (checked in Google Slides). Demo limit: 10 builds a day per connection.

Input parameters:

- `deck`: A typed scene list: {"title","target","scenes":[{"type":"title|bullets|stats|quote|table|media|cta","f":{...fields...},"notes":"speaker notes"}]}. Same scene fields as make_film (eyebrow, headline, s…
- `delivery` (string): How the .pptx comes back. link (default): a download link valid for one hour, which works in every client including chat apps that cannot receive attachments. file: the .pptx as an embedded resource,…
- `payload`: An A2UI payload {"blocks":[{"type":"quote",...},...]}: each atom with a slide recipe becomes slides, others are listed under `unsupported`, never guessed. deck_schema lists the atoms. Give payload OR…
- `skip_film_only` (boolean): For a scene list that came from a film: leave out scenes with no slide layout (chart, chat, word, morph, captions, image) instead of treating them as errors.
- `target` (string): Where the file will be opened. google-slides fits text tighter; powerpoint and any keep a 12% margin for a substituted font. Default any. Ask the user if you do not know.

### `drawio_open` (~822 tokens)

Open a diagram you wrote in draw.io (diagrams.net). YOU write the diagram as mxGraph XML, the format draw.io reads; this tool checks it, and returns a link that opens it in the draw.io editor for the person, plus a .drawio file to download (kept for one hour). Nothing is drawn or laid out for you, so give every shape its x, y, width and height. The XML must be uncompressed and shaped like this (ids unique, every shape parent="1", edges name source and target ids): <mxGraphModel><root><mxCell id="0"/><mxCell id="1" parent="0"/><mxCell id="a" value="Start" style="rounded=1;whiteSpace=wrap;html=1;" vertex="1" parent="1"><mxGeometry x="40" y="40" width="120" height="60" as="geometry"/></mxCell><mxCell id="b" value="Done" style="rounded=1;whiteSpace=wrap;html=1;" vertex="1" parent="1"><mxGeometry x="240" y="40" width="120" height="60" as="geometry"/></mxCell><mxCell id="e1" style="edgeStyle=orthogonalEdgeStyle;html=1;" edge="1" parent="1" source="a" target="b"><mxGeometry relative="1" as="geometry"/></mxCell></root></mxGraphModel> If the check finds problems it lists each one with the cell id and the fix; correct the XML and call again. Limits: 200 KB of XML and 500 cells. For AWS and Google Cloud diagrams the check also looks at missing labels, overlaps, text that does not fit, contrast and placement (for example an instance outside a subnet); each finding names the cell. These are vendor-style conventions drawn from draw.io's own libraries, not an official checker from AWS or Google. Labels may use simple HTML (set html=1 in the style); scripts, iframes, event handlers and javascript: links are refused. The diagram travels in the link's fragment, which is never sent to a server.

Input parameters:

- `animate` (boolean): Add moving dashes along the connectors (draw.io flow animation). Shows in the draw.io editor; default false.
- `host` (string): diagrams (default): open in app.diagrams.net. self: open in the editor hosted on a2uicatalog.ai, so the diagram never leaves this domain.
- `polish` (string): Visual finish using draw.io's own effects, layered on your styles without overriding any key you set: clean (default, nothing added), soft (rounded corners, gentle shadow, subtle gradient), glass (so…
- `restyle` (boolean): Rewrite recognised services to draw.io's own icon styles and recognised groups (AWS: VPC, subnets, Region; Google Cloud: zones) to their group styles. AWS has icons for 350 services; for Google Cloud…
- `style` (string): Style pack. auto (default): if the diagram names AWS or Google Cloud services, check it against that vendor's conventions and report findings. aws or gcp: force a pack. none: no style checks. Name a…
- `title` (string): Optional name for the downloaded file, for example "checkout-flow".
- `xml` (string, required): The mxGraph XML: an <mxGraphModel> (or an uncompressed <mxfile> holding one).

### `unlink_slack_account` (~131 tokens)

Revoke one or more Slack accounts' link to this reader's store, from the Workspace side (the reverse of the Slack-side `/a2ui unlink` command — see slack-compiler/DESIGN-identity.md, "many Slack -> one sub"). Removes that account's ability to post via render_reading_to_slack or resolve to this reader; everything else about the reader's account is untouched. Takes an array so the Workspace's multi-select can revoke a batch in one call.

Input parameters:

- `keys` (array, required): slack_key values from the Links view, "{team_id}:{user_id}".

Output parameters:

- `available` (boolean): False when there is no signed-in reader or the store failed.
- `note` (string): Guidance for the caller.
- `reason` (string): Why nothing was removed.
- `removed` (integer): Links removed.
- `requested` (integer): Keys requested.

### `wall_calc` (~299 tokens)

Compute a coursed block/brick wall specification — course and unit counts, weight, cost, mortar bags, a build-time curve across 1-6 builders, and load-bearing/height advisories. Pure arithmetic, no model call: a native-catalogue rebuild of the Gemini Enterprise "Wall Builder" demo, kept byte-for-byte correct against that original's formulas (see mcp-worker/test/test_wall_calc_parity.py). `country` is not an input — it is derived from block_id and returned in the result.

Input parameters:

- `block_id` (string, required): parpaing200/150 and brique are French standards; uk_brick/uk_block are UK standards. Determines unit dimensions, weight, and colour.
- `builders` (number): 1-6, snapped/clamped. Selects which point on the returned build_days_curve is build_days_selected.
- `height_m` (number, required): 0.2-20m, snapped to 0.2m steps.
- `include_dpc` (boolean): Adds a damp-proof-course length to the result.
- `load_bearing` (boolean): Triggers an advisory (not a block swap) if the chosen block is under the load-bearing weight threshold.
- `pattern` (string, required): running = half-unit stagger on alternate courses; stack = none.
- `width_m` (number, required): 0.2-20m, snapped to 0.2m steps.

Output parameters:

- `actual_h_mm` (number): Built height in mm.
- `actual_w_mm` (number): Built width in mm.
- `available` (boolean): Always true.
- `block_id` (string): Block id.
- `build_days_curve` (array): Build days per builder count.
- `build_days_selected` (number): Build days at the chosen builder count.
- `builders` (integer): Builders, snapped to range.
- `country` (string): Country the block spec is for.
- `courses` (integer): Courses of blocks.
- `dpc_length_m` (number): DPC length in metres.
- `height_advisory` (boolean): True when the wall is tall.
- `height_m` (number): Snapped wall height in metres.
- `height_mm` (number): Height in mm.
- `height_pct` (number): Height as a percentage of the maximum.
- `include_dpc` (boolean): Whether a damp-proof course is included.
- `load_bearing` (boolean): Whether load-bearing was requested.
- `load_bearing_advisory` (boolean): True when the block is too light for load-bearing.
- `mortar_bags` (integer): Mortar bags.
- `pattern` (string): Bond pattern.
- `per_course` (integer): Blocks per course.
- `total_cost` (number): Total block cost.
- `total_units` (integer): Total blocks.
- `total_weight_kg` (number): Total weight in kg.
- `width_m` (number): Snapped wall width in metres.
- `width_mm` (number): Width in mm.

### `whoami` (~103 tokens)

Report who this connection is authenticated as. Answers two SEPARATE questions that are easy to conflate: which APPLICATION is connected (the OAuth client), and which HUMAN authorised it (the signed-in account, when the endpoint is one that can know). The public endpoint is anonymous by design and will say so — that is not an error, it is the free tier. Use it to check whether per-user features (saved profile, reading history) are available before offering them.

Output parameters:

- `application` (string|null): OAuth client id, or null when anonymous.
- `authenticated` (boolean): True on the authenticated endpoint.
- `endpoint` (string): "public" or "authenticated".
- `note` (string): What this identity can do.
- `per_user_features` (boolean): True when a human is attributable.
- `user` (object|null): The signed-in user {sub, email}, or null.

### `identify_model` (~278 tokens)

CALL THIS FIRST, before any other a2ui-catalog tool, once per session. Declares your own model identity so this response can hand you capability-matched guidance up front — some models need simpler, judgment-free tools; skipping this just means you default to the full toolkit, including tools that require sizing/pagination judgment calls.

HOW TO ANSWER — do not guess:
\- Copy your model name EXACTLY as stated in your own system prompt or developer context (look for phrasing like "you are powered by the model named X" or similar). Do NOT infer it from your training cutoff, your own behavior, or general capability.
\- Examples of valid values: "claude-haiku-4-5", "claude-sonnet-5", "claude-opus-4-8", "gemini-2.0-flash", "gpt-4o". Partial names are fine ("haiku", "sonnet").
\- If your model name is genuinely not stated anywhere in your context, pass "unknown" — do NOT guess a plausible-sounding value. A wrong report is worse than no report: it can hand you tools you cannot reliably operate.

Input parameters:

- `model` (string, required): Your own model identifier, exactly as your system prompt states it, or "unknown" if not stated. Do not guess.

Output parameters:

- `guidance` (string): Capability-matched advice.
- `recognized_as` (string): Model name as declared, lower-cased, or "unknown".
- `recommended_tools` (array): Tool names to prefer.
- `tier` (string): Capability tier.

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/ai-a2uicatalog-catalog/a2uicatalog#diagnostics

## Score history

- 2026-11-21: 67
- 2026-11-20: 67
- 2026-11-19: 66
- 2026-11-18: 66
- 2026-11-17: 65
- 2026-11-16: 65
- 2026-11-15: 64
- 2026-11-14: 64
- 2026-11-13: 64
- 2026-11-12: 63
- 2026-11-11: 62
- 2026-11-10: 62

## Common questions

### What is the A2UI Atomic Catalog MCP server?

A2UI Atomic Catalog is an MCP server listed in the public MCP registry as ai.a2uicatalog/catalog. 500+ typed UI atoms an agent composes into real rendered interfaces. Free, no API key. This page covers its hosted endpoint (https://a2uicatalog.ai/mcp).

### Is the A2UI Atomic Catalog MCP server safe to use?

A2UI Atomic Catalog scores 67 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the A2UI Atomic Catalog MCP server expose?

A2UI Atomic Catalog exposes 40 tools: list_catalogs, get_catalog, find_atoms, get_atom_schema, required_catalogs, and 35 more. Their descriptions and schemas cost roughly 9,407 tokens of context every time the server is loaded.

### Does the A2UI Atomic Catalog MCP server require authentication?

No. We connected to A2UI Atomic Catalog without credentials and it answered, so anything it exposes is reachable by anyone who knows the address.

### Is the A2UI Atomic Catalog MCP server still maintained?

A2UI Atomic Catalog is still listed as active in the MCP registry. We last reached this channel on 21 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What did VerifyMCP test on the A2UI Atomic Catalog MCP server?

VerifyMCP ran 14 checks on A2UI Atomic Catalog, covering TLS certificate, Authorization, HTTPS, HSTS header and 10 more. Supply Chain Security and Provenance & Transparency do not apply to a hosted endpoint, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- Remote endpoint: https://a2uicatalog.ai/mcp
- Repository: https://github.com/a2uicatalog/a2ui
- Website: https://a2uicatalog.ai/
- Changelog RSS feed: https://verifymcp.io/servers/ai-a2uicatalog-catalog/a2uicatalog.xml
- Changelog JSON feed: https://verifymcp.io/servers/ai-a2uicatalog-catalog/a2uicatalog/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/ai-a2uicatalog-catalog/a2uicatalog.json
- HTML version of this page: https://verifymcp.io/servers/ai-a2uicatalog-catalog/a2uicatalog
