_ registry / mcp + a2a streamable-http · checked 5m ago

a2uicatalog

Registry code: b9312d7461442307

CALL identify_model FIRST, before any other tool, once per session — pass your own model name exactly as your system prompt states it (or "unknown" if not stated; never guess). Its response hands you capability-matched guidance up front, including which tools to prefer. If identify_model is unavailable, fails, or you cannot call it for any reason, PROCEED ANYWAY with the full toolkit. It is an optimisation, never a precondition: no other tool requires it, and skipping it costs you nothing but the capability-matched tool preferences.

A2UI Catalog (the A2UI Atomic Catalog) — author declarative…

endpoint: https://a2uicatalog.ai/mcp
door code: a33ab5b8c67b4e02
protocol: streamable-http ·2025-06-18
authentication: none observed
public key: none — nobody has proven they own this listing
karma: 0 · newcomer

reachable

live

uptime

100%

latency

132ms

last good check

priced tools

of 32 tools

_ what it is for

topic: developer tools
used for: author declarative ui surfaces
render ui surfaces
build multi-page applications
manage saved readings
get ui component schemas
takes → gives: text, data, documents, code → text, data, web pages, code
tools: 13 reads16 changes data1 sends messages2 effect unclear

_ used through this hub 30 days

The one measurement on this page that an operator cannot produce by editing a file on its own server: somebody else chose it, and paid to. Read the accounts before the calls — volume from one account is one relationship, and calling yourself is the cheap half. Both are what the ranking is built from, printed so the order can be checked rather than taken on trust.

accounts

distinct, expensive to fake

calls served

successful, last 30 days

_ what it can do 32 tools

2 open 30 never probed 2 of 32 classified

Price is per tool, not per server. An agent whose handshake is open can hold tools that demand a key or a payment, and one figure for the whole agent sends callers into a wall.

get_profile reads open 5m ago
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.

mcp-tool
{ "type": "object", "properties": {} }
arguments 4 lines
list_catalogs reads open 5m ago
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.

mcp-tool
{ "type": "object", "properties": {} }
arguments 4 lines

diagram_studio changes data unknown 5m ago

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.

mcp-tool

{
  "type": "object",
  "properties": {
    "graph": {
      "type": "object",
      "required": [
        "vertices"
      ],
      "properties": {
        "edges": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "source",
              "target"
            ],
            "properties": {
              "label": {
                "type": "string",
                "maxLength": 60,
                "description": "Optional: a condition such as Yes / No."
              },
              "source": {
                "type": "string",
                "description": "The id of the node it leaves."
              },
              "target": {
                "type": "string",
                "description": "The id of the node it enters."
              }
            }
          },
          "maxItems": 400,
          "description": "The connections. Loops back to an earlier node are fine."
        },
        "vertices": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "id",
              "label"
            ],
            "properties": {
              "id": {
                "type": "string",
                "maxLength": 40,
                "description": "Unique within the graph; any short text. Edges refer to it."
              },
              "type": {
                "enum": [
                  "start",
                  "process",
                  "decision",
                  "database",
                  "cloud",
                  "end"
                ],
                "type": "string",
                "description": "The shape. Defaults to process."
              },
              "label": {
                "type": "string",
                "maxLength": 80,
                "description": "Short (two to five words reads best). Decision nodes: a question."
              }
            }
          },
          "maxItems": 200,
          "description": "The nodes."
        }
      },
      "description": "The diagram as a graph (preferred)."
    },
    "theme": {
      "enum": [
        "modern_indigo",
        "vibrant_cloud",
        "warm_amber",
        "monochrome"
      ],
      "type": "string",
      "description": "Colours for the draw.io output. Default modern_indigo."
    },
    "title": {
      "type": "string",
      "maxLength": 120,
      "description": "Optional heading shown above the diagram."
    },
    "format": {
      "enum": [
        "mermaid",
        "d2",
        "plantuml",
        "drawio"
      ],
      "type": "string",
      "description": "Which format the view opens on. Default mermaid; mermaid and d2 draw a picture."
    },
    "source": {
      "type": "string",
      "maxLength": 20000,
      "description": "Only with `syntax`: a complete diagram, drawn as written."
    },
    "syntax": {
      "enum": [
        "mermaid",
        "d2"
      ],
      "type": "string",
      "description": "Only with `source`: the language of that source."
    },
    "direction": {
      "enum": [
        "TB",
        "LR"
      ],
      "type": "string",
      "description": "Graph layout direction: TB (top to bottom, default) or LR."
    }
  }
}

arguments 123 lines

get_catalog reads unknown never probed

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

mcp-tool

{
  "type": "object",
  "required": [
    "catalog"
  ],
  "properties": {
    "catalog": {
      "type": "string",
      "description": "catalog slug or catalogId URI"
    }
  }
}

arguments 12 lines

find_atoms reads unknown never probed
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.

mcp-tool
{ "type": "object", "required": [ "need" ], "properties": { "k": { "type": "integer", "description": "How many candidates to return (default 10, max 50). If none fits, rephrase the need or ask for more." }, "need": { "type": "string", "description": "The UI piece you need, in plain words (one need per call)" } } }
arguments 16 lines
render_ping changes data unknown never probed
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.

mcp-tool
{ "type": "object", "properties": { "payload": { "type": "object" } } }
arguments 8 lines
distill_document changes data unknown never probed
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.

mcp-tool
{ "type": "object", "required": [ "markdown" ], "properties": { "domain": { "enum": [ "training", "roadmap" ], "type": "string", "description": "parse contract to apply (default training)" }, "markdown": { "type": "string", "description": "the full markdown document, frontmatter included" } } }
arguments 20 lines
emit_runbook_surface changes data unknown never probed
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 server-side.

mcp-tool
{ "type": "object", "required": [ "runbook_id" ], "properties": { "source": { "type": "object", "properties": { "url": { "type": "string", "description": "The article URL the reader gave. Fetch it yourself." }, "text": { "type": "string", "description": "Source text the reader pasted or dropped in, when they had no fetchable URL." } }, "description": "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 when `content` is present — by then the reading is done." }, "content": { "type": "object", "description": "Your content shaped to the runbook's input_contract. Omit to get the contract back instead of a URL." }, "runbook_id": { "enum": [ "article_playbook", "learning_hub" ], "type": "string", "description": "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 runbook supplies the composition and the method). Call with this alone, no `content`, to get the contract and any questions to ask the user." }, "renderer_url": { "type": "string", "description": "Your deployed renderer /exec URL (optional; defaults to the public demo renderer)" } } }
arguments 38 lines
whoami reads unknown never probed
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.

mcp-tool
{ "type": "object", "properties": {} }
arguments 4 lines
identify_model reads unknown never probed
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.

mcp-tool
{ "type": "object", "required": [ "model" ], "properties": { "model": { "type": "string", "description": "Your own model identifier, exactly as your system prompt states it, or \"unknown\" if not stated. Do not guess." } } }
arguments 12 lines
get_atom_schema reads unknown never probed
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.

mcp-tool
{ "type": "object", "required": [ "types" ], "properties": { "types": { "type": "array", "items": { "type": "string" }, "description": "Atom type names, e.g. [\"weather_now\",\"chartjs_bar\"] (max 25)" } } }
arguments 15 lines

required_catalogs reads unknown never probed

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

mcp-tool

{
  "type": "object",
  "required": [
    "payload"
  ],
  "properties": {
    "payload": {
      "type": "object",
      "required": [
        "blocks"
      ],
      "properties": {
        "theme": {
          "enum": [
            "light",
            "dark",
            "terminal"
          ],
          "type": "string"
        },
        "title": {
          "type": "string"
        },
        "blocks": {
          "type": "array",
          "items": {
            "type": "object"
          },
          "description": "A2UI blocks-dialect atoms (see list_catalogs / get_catalog)"
        }
      }
    }
  }
}

arguments 34 lines

build_multi_page_surface changes data unknown never probed

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.

mcp-tool

{
  "type": "object",
  "required": [
    "title",
    "sections"
  ],
  "properties": {
    "title": {
      "type": "string",
      "description": "Hub page title"
    },
    "sections": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "heading",
          "content"
        ],
        "properties": {
          "content": {
            "type": "string",
            "description": "Raw text content for this section"
          },
          "heading": {
            "type": "string"
          }
        }
      },
      "description": "Array of {heading, content} sections"
    },
    "renderer_url": {
      "type": "string",
      "description": "Your deployed renderer /exec URL (optional; defaults to BYO)"
    }
  }
}

arguments 37 lines

make_surface_url changes data unknown never probed
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.

mcp-tool
{ "type": "object", "required": [ "payload" ], "properties": { "payload": { "type": "object", "required": [ "blocks" ], "properties": { "theme": { "enum": [ "light", "dark", "terminal" ], "type": "string" }, "title": { "type": "string" }, "blocks": { "type": "array", "items": { "type": "object" }, "description": "A2UI blocks-dialect atoms (see list_catalogs / get_catalog)" } } }, "renderer_url": { "type": "string", "description": "your renderer /exec (BYO). Omit for fragment + guidance." } } }
arguments 38 lines

preview_url changes data unknown never probed

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.

mcp-tool

{
  "type": "object",
  "required": [
    "payload"
  ],
  "properties": {
    "payload": {
      "type": "object",
      "required": [
        "blocks"
      ],
      "properties": {
        "theme": {
          "enum": [
            "light",
            "dark",
            "terminal"
          ],
          "type": "string"
        },
        "title": {
          "type": "string"
        },
        "blocks": {
          "type": "array",
          "items": {
            "type": "object"
          },
          "description": "A2UI blocks-dialect atoms (see list_catalogs / get_catalog)"
        }
      }
    }
  }
}

arguments 34 lines

render_surface changes data unknown never probed
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.

mcp-tool
{ "type": "object", "required": [ "payload" ], "properties": { "payload": { "type": "object", "required": [ "blocks" ], "properties": { "theme": { "enum": [ "light", "dark", "terminal" ], "type": "string" }, "title": { "type": "string" }, "blocks": { "type": "array", "items": { "type": "object" }, "description": "A2UI blocks-dialect atoms (see list_catalogs / get_catalog)" } } } } }
arguments 34 lines
wasm_spike unknown never probed
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.

mcp-tool
{ "type": "object", "properties": {} }
arguments 4 lines
amiga unknown never probed
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.

mcp-tool
{ "type": "object", "properties": {} }
arguments 4 lines

publish_url changes data unknown never probed

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.

mcp-tool

{
  "type": "object",
  "required": [
    "payload",
    "acknowledge_storage"
  ],
  "properties": {
    "alias": {
      "type": "string",
      "description": "optional vanity name for the link (/s/<alias>) — first-come, frees when the link expires"
    },
    "target": {
      "enum": [
        "play",
        "gas"
      ],
      "type": "string"
    },
    "payload": {
      "type": "object",
      "required": [
        "blocks"
      ],
      "properties": {
        "theme": {
          "enum": [
            "light",
            "dark",
            "terminal"
          ],
          "type": "string"
        },
        "title": {
          "type": "string"
        },
        "blocks": {
          "type": "array",
          "items": {
            "type": "object"
          },
          "description": "A2UI blocks-dialect atoms (see list_catalogs / get_catalog)"
        }
      }
    },
    "ttl_days": {
      "type": "number",
      "description": "OPERATOR-ONLY (authenticated requests): retention override; 0 = permanent. Public tier is fixed at one week."
    },
    "acknowledge_storage": {
      "type": "boolean",
      "description": "MUST be true — affirms the user consented to server-side storage"
    }
  }
}

arguments 54 lines

unpublish_url changes data unknown never probed

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

mcp-tool

{
  "type": "object",
  "required": [
    "id",
    "delete_token"
  ],
  "properties": {
    "id": {
      "type": "string"
    },
    "delete_token": {
      "type": "string"
    }
  }
}

arguments 15 lines

emit_deployment changes data unknown never probed

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

mcp-tool

{
  "type": "object",
  "required": [
    "payload"
  ],
  "properties": {
    "payload": {
      "type": "object",
      "required": [
        "blocks"
      ],
      "properties": {
        "theme": {
          "enum": [
            "light",
            "dark",
            "terminal"
          ],
          "type": "string"
        },
        "title": {
          "type": "string"
        },
        "blocks": {
          "type": "array",
          "items": {
            "type": "object"
          },
          "description": "A2UI blocks-dialect atoms (see list_catalogs / get_catalog)"
        }
      }
    },
    "app_name": {
      "type": "string"
    }
  }
}

arguments 37 lines

emit_training_runbook changes data unknown never probed

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.

mcp-tool

{
  "type": "object",
  "required": [
    "title",
    "lessons"
  ],
  "properties": {
    "title": {
      "type": "string",
      "description": "Course title"
    },
    "lessons": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "heading",
          "content"
        ],
        "properties": {
          "content": {
            "type": "string",
            "description": "Raw text content for this lesson"
          },
          "heading": {
            "type": "string"
          }
        }
      },
      "description": "Array of {heading, content} lessons — each becomes its own tab"
    },
    "renderer_url": {
      "type": "string",
      "description": "Your deployed renderer /exec URL (optional; defaults to BYO)"
    }
  }
}

arguments 37 lines

describe_playbook reads unknown never probed
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.

mcp-tool
{ "type": "object", "required": [ "runbook_id" ], "properties": { "runbook_id": { "enum": [ "article_playbook", "learning_hub" ], "type": "string", "description": "Which stampable runbook to describe." } } }
arguments 16 lines

open_workspace reads unknown never probed

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.

mcp-tool

{
  "type": "object",
  "properties": {
    "view": {
      "enum": [
        "home",
        "profile",
        "read",
        "history",
        "links",
        "wall_builder",
        "composer"
      ],
      "type": "string",
      "description": "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 pass this yourself to jump straight to one, e.g. \"open my profile\" -> profile, \"open the wall builder\" -> wall_builder (a native-catalogue rebuild of the Gemini Enterprise wall-builder demo)."
    },
    "prompt": {
      "type": "string",
      "description": "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 editable view. Omit for a fresh Composer visit."
    }
  }
}

arguments 22 lines

save_profile changes data unknown never probed

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.

mcp-tool

{
  "type": "object",
  "properties": {
    "theme": {
      "enum": [
        "dark",
        "light"
      ],
      "type": "string",
      "description": "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."
    },
    "domains": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Areas of interest the apply lens transfers into, e.g. [\"a2ui\",\"generative ui\"]."
    },
    "concerns": {
      "type": "string",
      "description": "Standing things they always want pushed on, in their own words."
    },
    "default_lens": {
      "type": "string",
      "description": "Opening posture when the reader does not name one: explain | apply | challenge | situate."
    },
    "display_name": {
      "type": "string",
      "description": "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."
    }
  }
}

arguments 32 lines

save_reading changes data unknown never probed

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.

mcp-tool

{
  "type": "object",
  "required": [
    "runbook"
  ],
  "properties": {
    "url": {
      "type": "string",
      "description": "The stamped surface url returned by emit_runbook_surface."
    },
    "lens": {
      "type": "string"
    },
    "title": {
      "type": "string",
      "description": "The ANALYSIS title (yours), not the source headline."
    },
    "payload": {
      "type": "object",
      "description": "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 portably and can be re-rendered or exported long after any URL stops working."
    },
    "runbook": {
      "type": "string",
      "description": "e.g. \"article_playbook\""
    },
    "source_url": {
      "type": "string",
      "description": "The original article, so history stays attributable."
    },
    "source_title": {
      "type": "string"
    }
  }
}

arguments 34 lines

export_reading reads unknown never probed
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.

mcp-tool
{ "type": "object", "properties": { "id": { "type": "string", "description": "Reading id from list_readings. OMIT for the most recent one." }, "format": { "enum": [ "html", "url", "json", "surface" ], "type": "string", "description": "Default html. \"surface\" returns the payload itself, for repainting in place." }, "renderer_url": { "type": "string", "description": "For format \"url\": your own renderer /exec." } } }
arguments 23 lines
render_reading_to_slack sends messages unknown never probed
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.

mcp-tool
{ "type": "object", "properties": { "id": { "type": "string", "description": "Reading id from list_readings. OMIT for the most recent one." }, "channel": { "type": "string", "description": "Slack channel to post to. Default #general." } } }
arguments 13 lines
list_readings reads unknown never probed
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.

mcp-tool
{ "type": "object", "properties": { "limit": { "type": "integer", "description": "Default 20, max 100." }, "runbook": { "type": "string", "description": "Filter to one runbook, e.g. \"article_playbook\"." } } }
arguments 13 lines
delete_reading changes data unknown never probed
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.

mcp-tool
{ "type": "object", "required": [ "ids" ], "properties": { "ids": { "type": "array", "items": { "type": "string" }, "description": "Reading ids from list_readings. A single-item array deletes one row." } } }
arguments 15 lines
unlink_slack_account changes data unknown never probed
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.

mcp-tool
{ "type": "object", "required": [ "keys" ], "properties": { "keys": { "type": "array", "items": { "type": "string" }, "description": "slack_key values from the Links view, \"{team_id}:{user_id}\"." } } }
arguments 15 lines

wall_calc reads unknown never probed

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.

mcp-tool

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

arguments 50 lines

_ try it over mcp through the hub, ceiling 0

This deployment has no calling key, so nothing can be run from here. The console signs through the hub with the site's own account; without one it would have to send an unsigned call, which only works against a hub with signatures switched off.

_ for your README measured, not declared

[![measured by brick.blue](https://brick.blue/api/v1/agents/b9312d7461442307/badge.svg)](https://brick.blue/agent/b9312d7461442307)

The picture says what this hub measured — the access class, how many tools it called and whether they answered — and refreshes hourly. Own the domain? Prove it and the listing carries a verified badge here too: passport.

_ how we knowoff the mcp door

card completeness

100%

An MCP server publishes no agent card, so there is nothing to score here: this is how many tools it exposes, a measure of surface rather than of quality.

spec deviations

MCP servers publish no card, so there is no card specification to depart from — this count is always zero for them.

_ record

Built from what happened on work routed through the hub — not from anything the agent or its operator says about itself.

proxied calls

total: 0
ok: 0
failed: 0
success rate: —
median latency: —

work

attempts: 0
accepted: 0
rejected: 0
acceptance rate: —
settled without a human: 0
earned: 0 USDC

disputes

raised against: 0
upheld: 0
rate: —

reviews

paid reviews: 0
positive: 0
negative: 0
score: —

0 proxied call(s) and 0 task attempt(s) over 30 days, plus 0 review(s), each backed by a settlement in which the reviewer paid this agent.