Agent Skills + MCP server discovery for cnvs.app — the free, no-signup real-time collaborative whiteboard. Any AI agent can read, write, draw, diagram, and subscribe to live human edits on a shared canvas, either through the hosted MCP server or the REST fallback.
Works with Claude Code, Claude Desktop, Cursor, OpenCode / OpenAI Codex, Aider (with MCP plugin), any other MCP-speaking client, and Hermes-family agents.
Real-time collaborative whiteboard — AI agents and humans edit the same board live over MCP.
2026-11-14
Uptimeletzte 1 Prüfungen
Sterne
—
Tools
26
Uptime
100%
MCP Server
Endpoint: https://cnvs.app/mcp (Streamable HTTP, protocol 2025-06-18, no auth — the board ID is the access key).
Tools (25): board creation and inspection; visual previews; text, link, image, and stroke editing; movement and deletion; live-update waits; and complete kanban column, lane, task, query, and export workflows. The exact production list is published in /.well-known/mcp.json. State-changing operations also have REST mirrors under https://cnvs.app/api/boards/<id>/… for runtimes that cannot speak MCP.
Resources (3): cnvs://board/{id}/state.json (full snapshot), cnvs://board/{id}/preview.svg (visual render), and cnvs://board/{id}/tasks.json (kanban state). All three are subscribable.
Subscriptions: resources/subscribe supported with notifications/resources/updated pushed over SSE, debounced ~3 s after activity settles.
claude mcp add --transport http cnvs https://cnvs.app/mcp
REST-only (no MCP client)
# Create a board
curl -X POST https://cnvs.app/api/boards
# Add text
curl -X POST https://cnvs.app/api/boards/<id>/texts \
-H 'Content-Type: application/json' \
-d '{"x":100,"y":200,"content":"# Hello","author":"ai:myagent"}'
# Long-poll for live changes
curl "https://cnvs.app/api/boards/<id>/wait?timeout_ms=25000"
There is no account or OAuth flow. A board URL or board ID is a bearer-style access credential: anyone who knows an unlocked board URL can open it. Boards can optionally require an 8-character lowercase alphanumeric access key for writes or for both reads and writes; legacy 6-character keys remain accepted. Pass a key only through the MCP tool's access_key argument or the X-Board-Key HTTP header.
Do not paste private board URLs or access keys into public issues, logs, or repositories.
Useful prompts
Create a fresh whiteboard for our brainstorming session and return its URL.
Open this cnvs.app board, inspect its preview, and summarize the layout.
Turn this list into a shared kanban board with priorities and owners.
Skills included
Two related Agent Skills live in this repo, published under the agentskills.io open standard so they work in any compatible runtime. Both are optional and installed by the user (agents should only suggest them, never install them on their own). Installed into ~/.claude/skills/, they teach the agent how to use the MCP server well (preview-before-JSON, REST-over-MCP for writes, author-tag conventions, subscription-then-react loop).
Teaches an AI agent how to collaborate on a cnvs.app board in real time:
Read the shared canvas state
Draw / diagram / flowchart / annotate — add, update, move, and delete text, links, sticky notes, strokes, images, and Mermaid diagrams (flowcharts, sequence / class / ER diagrams, mind maps, gantt charts, concept maps)
Render the SVG preview when the board contains drawings
Subscribe to live human edits via MCP, react via REST
Activates on any cnvs.app board reference (URL https://cnvs.app/#<id>, cnvs://board/<id>/..., or a bare board ID) or phrases like "collaborate on / draw / diagram / annotate / watch a shared whiteboard or canvas."
Push-to-model pump for Streamable-HTTP MCP servers with capabilities.resources.subscribe: true. Opens a session, subscribes to the resource URIs the caller hands over, and emits one JSON line per notifications/resources/updated event on stdout — designed to be wrapped by Claude Code's Monitor tool so every server push becomes an in-chat notification (no polling, no log tailing).
Dependency-free since v0.4. A single scripts/listen.mjs using only Node.js 18+ built-ins — no package.json, no npm install, no install scripts. Releases are served from immutable versioned URLs (https://cnvs.app/mcp-listen/v<version>/…) with a SHA256SUMS file. Zero-install alternative: the REST long-poll GET https://cnvs.app/api/boards/<id>/wait?timeout_ms=25000 (or the wait_for_update MCP tool).
Helper-only activation since v0.3. Triggers only when the caller — a user or another skill — has supplied both an MCP server URL and at least one resource URI. Does NOT auto-activate from generic phrasing like "watch this file" or "stay in the loop". cnvs-whiteboard is the canonical caller and delegates its push channel here.
Output split since v0.3. Only the actionable resource_updated event reaches stdout by default. Connection / subscription / heartbeat / transient-error events go to stderr so a wrapping Monitor doesn't fire on the listener's own bookkeeping. Pass --verbose (or -v) to merge everything onto stdout for debugging or single-channel logging (legacy v0.2 behavior).
Registry status. Intentionally not listed in centralised skill registries yet. Current registry pipelines (e.g. majiayu000/claude-skill-registry-core as of 2026-05-03) archive only SKILL.md + generated metadata; they do not mirror bundled scripts/**, so an entry for mcp-listen would publish a broken skill. It will be (re-)submitted once core registries support directory-style skill archival with bundled-file mirroring and security scanning — see PR majiayu000/claude-skill-registry-core#40 for the directory-archive primitive that just landed and the open question on bundled-script scanning. Until then, install it via curl from cnvs.app (below) or git clone this repo.
Install the skills (run these yourself)
# cnvs-whiteboard (SKILL.md only — no code)
mkdir -p ~/.claude/skills/cnvs-whiteboard && cd ~/.claude/skills/cnvs-whiteboard
curl -fsSLO https://cnvs.app/cnvs-whiteboard/SKILL.md
# mcp-listen (pinned version, no npm, Node.js 18+). Files are downloaded into a
# staging dir and only moved into ~/.claude/skills/mcp-listen if every checksum
# matches. On Linux replace `shasum -a 256 -c` with `sha256sum -c`.
stage="$(mktemp -d)" && cd "$stage" && mkdir scripts \
&& curl -fsSLO https://cnvs.app/mcp-listen/v0.4.0/SKILL.md \
&& curl -fsSLO https://cnvs.app/mcp-listen/v0.4.0/SHA256SUMS \
&& curl -fsSL -o scripts/listen.mjs https://cnvs.app/mcp-listen/v0.4.0/scripts/listen.mjs \
&& shasum -a 256 -c SHA256SUMS \
&& mkdir -p ~/.claude/skills && rm -rf ~/.claude/skills/mcp-listen \
&& mv "$stage" ~/.claude/skills/mcp-listen && cd ~/.claude/skills/mcp-listen \
&& node scripts/listen.mjs --version # 0.4.0
Alternatively git clone this repo, check cd mcp-listen && shasum -a 256 -c SHA256SUMS, and cp -r .claude/skills/* ~/.claude/skills/ — the .claude/skills/ directory contains symlinks into cnvs-whiteboard/ and mcp-listen/ for Claude Code's expected layout.
description under 1024 characters, imperative phrasing, explicit trigger keywords
scripts/ subdirectory for bundled code (mcp-listen)
license: MIT, compatibility field declared, cross-references in each skill's "Related skills" section to prevent activation overlap
Why two skills
Earlier versions had a single page (/skill-cnvs.md on cnvs.app — now a legacy redirect). Splitting into two coherent units follows the spec's "design coherent units" best practice:
mcp-listen owns the generic push-to-model pattern (usable against any MCP server).
Cross-references keep them pairing cleanly: cnvs-whiteboard mentions mcp-listen as its delegated push channel; mcp-listen mentions cnvs-whiteboard as the companion for cnvs-specific work. No activation overlap in practice.
This repo is a mirror of public/ in the cnvs.app source; the versioned cnvs.app URLs are the canonical install targets; this GitHub repo is the reference for aggregators that crawl public sources (skills.sh, etc.) and for users who prefer git clone.
Discovery surfaces
Live
Official MCP Registry: app.cnvs/whiteboard — browse
cnvs.app /.well-known/mcp.json — links both skills
cnvs.app /.well-known/mcp/server.json — MCP Registry entry with publisher-provided _meta.skills[]
cnvs.app /llms.txt — LLM-friendly full reference
majiayu000/claude-skill-registry-core — cnvs-whiteboard listed (PR #31 merged 2026-05-04). mcp-listen intentionally held back; see Registry status on the mcp-listen/ section above.
Lobehub (used by Hermes agent) — both skills imported; MCP server submitted
Planned / under consideration
Notes for future expansion of distribution. Not active yet — kept here so the next maintenance window doesn't have to re-discover the landscape.
majiayu000/claude-skill-registry-core — re-submit mcp-listen as a separate PR now that PR #40 (directory archives + bundled-script security scanning) is merged. scripts/listen.mjs is even hardcoded into their test assertions, so the pipeline already exercises our exact case.
daymade/claude-code-skills (vendored model) — fork, copy cnvs-whiteboard/ and mcp-listen/ directly into their tree (their layout already expects scripts//references//assets/), update marketplace.json, single PR for both skills. No bundled-files concern because the files are copied in.
VoltAgent/awesome-agent-skills (curated awesome-list, 20k ⭐) — markdown link, ≤10-word description. Their CONTRIBUTING explicitly excludes brand-new skills ("give your skill time to mature and gain users before submitting"); revisit once there's documented external usage.
sickn33/antigravity-awesome-skills (36k ⭐) — manual path: fork, add skills/<name>/SKILL.md, run npm run validate. Their `` header in README suggests automated pull from upstream registries, so a successful entry on majiayu000/claude-skill-registry-coremay propagate here without a separate PR — confirm before submitting twice.
agentskills/agentskills (17.8k ⭐, the spec org behind agentskills.io) — investigate whether they accept reference implementations; mcp-listen as a worked example of MCP resources/subscribe consumption could fit there.
vercel-labs/agent-skills / vercel-labs/skills — almost certainly curated, but read CONTRIBUTING before ruling out.
Skipped intentionally: anthropics/skills (curated, no community PRs); personal collections under ~100 ⭐; language-specific lists unless a relevant audience emerges.
ALWAYS call this first when given a board URL or ID. Resolves the canonical board id and auto-creates the board row if it does not exist yet. Returns a summary (item counts, authors). After this, call BOTH `get_preview` and `get_board` before editing so you can see the layout visually AND know the e
Create a fresh board in ONE call — optionally pre-filled with content, auto-laid-out, and/or PIN-locked at create time. Mirrors the extended `POST /api/boards` REST body exactly (same server-side implementation). With no arguments it returns a blank draw board; `mode: 'todo'` (+ optional `template`)
Full structured JSON state of a board: texts (id, x, y, content, color, width, postit, author), strokes (id, points, color, author), images (id, x, y, width, height, dataUrl, thumbDataUrl, author; heavy base64 >8 kB elided to dataUrl:null, tiny images inlined). Use this for EXACT ids/coordinates/con
Compact schematic SVG render of the board (typically a few kB even for dense boards). Returns both an image/svg+xml content block (you can SEE it) and the raw SVG text. CALL THIS any time you need to understand where things are — before placing new items, before deciding whether the canvas is crowde
Create a NEW text node, or update an existing one (pass the same `id` to overwrite content/position in place — preferred over creating a duplicate). Supports cnvs markup (Markdown-ish) and Mermaid diagrams in the content. When using Mermaid, the ENTIRE content of this text node must be a single Merm
Drop a URL capsule onto the board — rendered as a clickable pill showing the hostname. Use this instead of `add_text` when the node is just a link; the capsule styling signals clickability to humans. Same coordinate rules as `add_text` (+x right, +y down).
Place a raster or SVG image on the board at (x, y) with explicit width/height in board pixels. `data_url` MUST be a `data:image/(png|jpeg|gif|webp|svg+xml);base64,...` string ≤ ~900 kB; hosted URLs are not accepted. The bytes are header-checked (the leading bytes must be PNG/JPEG/GIF/WebP/SVG; not a
Draw a freehand stroke on the board. Use for arrows, underlines, connector lines, annotations, or simple shapes — a straight line needs two points, a rough circle wants ~20. Stroke width is fixed at 3 px; `color` is a NAME, not hex (case-insensitive): 'auto'/''/'black'/omitted for theme-aware ink, o
Reposition an existing item to a new (x, y) without retyping its content. Works for every item kind: `text` and `link` set the top-left to (x, y); `line` translates every point so the stroke's bounding box top-left lands at (x, y); `image` sets the top-left like text. `kind` defaults to `text` for b
Delete a single item by id. `kind` MUST match the item type: 'text' for text nodes, 'line' for freehand strokes, 'image' for images — the wrong kind silently targets the wrong table and is a common mistake. Get the id + type from `get_board` (texts[], lines[], images[]). There is no bulk/erase-all t
Long-poll: blocks until the next edit lands on this board, then returns.
WHEN TO CALL THIS: if your MCP client does NOT surface `notifications/resources/updated` events from `resources/subscribe` back to the model (most chat clients do not — they receive the SSE event but don't inject it into your
Choose whether this board is a freeform whiteboard ('draw', the default) or a kanban task board ('todo'). Mode is switchable WHENEVER the board is empty of real content: drawings (text/strokes/images) and tasks. Empty or seeded columns DON'T count (switching to 'draw' clears them), so a cleared boar
Add a kanban column (swimlane) to a 'todo' board. Generates and returns a stable column id. `sort` is a float ordering key (ascending); omit to default to 0. `lane` is an integer row index for multi-row layouts (defaults to 0). `color` is an optional title color ('red' / 'blue' / 'green', or 'auto'
Create a task (card) in a column on a 'todo' board. Generates and returns a stable task id. `column_id` must reference an existing column (see `list_tasks`). `description` is free-form prose stored on the card; `priority` is one of 'H' | 'M' | 'L' (omit for none); `due_date` is an ISO 8601 date stri
Update an existing task by `id` (from `list_tasks`). Pass only the fields you want to change: `name`, `description`, `due_date`, `priority` ('H'|'M'|'L'), `assignee`, `done` (true once completed), `column_id` (to reassign), `sort`. To move a card between columns while setting its order, `move_task`
Move a task to a column at a given sort position — the kanban drag-and-drop primitive. `column_id` is the destination column and `sort` its float order key (ascending) within that column.
Read the full kanban state of a 'todo' board: `{ mode, columns, tasks }`, both ordered by their `sort` key (ascending). Each task carries its hot fields (name, due_date, priority, assignee, done, column_id, sort) plus an opaque `content` JSON string (holds the description). Use this to get exact col
Set (or clear) the title of a kanban row (lane). Lanes group columns into horizontal swimlanes; a lane is identified by its integer `lane` index (the same index columns carry). Pass a `title` to name the row, or an empty string to clear it. Read current lane titles + the shared column width via `lis
Set the shared kanban column width in pixels for a 'todo' board (all columns share one width). Clamped to [200, 480]. Read the current value as `colWidth` from `list_tasks`.
Set the shared board name shown to every collaborator (rail label, tab title, export filenames). Works in draw and todo mode. Whitespace is collapsed; max 100 chars. Pass `name: null` or "" to clear (clients then show the board id). Read it as `name` from `get_board` / `list_tasks`.
Bulk-create multiple task cards in one call — far cheaper than calling `create_task` N times. Pass `tasks`: an array of task objects, each with `column_id` (required) + the same fields `create_task` accepts (`name`, `description`, `due_date`, `priority`, `assignee`, `done`, `sort`). Returns the arra
Read tasks from a 'todo' board with server-side filtering — handy for 'what's overdue?' / 'what's assigned to X?' without pulling the whole board. All filters are optional and AND together: `assignee` (exact match), `priority` ('H'|'M'|'L'), `done` (boolean), `overdue` (true → due_date strictly befo
Export a 'todo' board's columns + tasks as a single text document. `format` is 'markdown' (a checklist grouped by column, the default) or 'csv' (one row per task with column/name/priority/assignee/due_date/done). Returns the rendered text. Same data as the GET /api/boards/<id>/tasks.md and tasks.csv
Kopieren Sie auf dieser Seite die http-Konfiguration für Cursor, Claude Desktop, Claude Code oder VS Code. Sie nutzt die Installation des Herausgebers, keinen PlugMCP-Proxy.
Benötigt Cnvs.app einen API-Schlüssel?
In diesem Eintrag ist keine erforderliche Umgebungsvariable aufgeführt.
Welchen Transport verwendet Cnvs.app?
Cnvs.app wird über HTTP erreicht.
Wann wurde Cnvs.app zuletzt geprüft?
Zuletzt geprüft: 2026-11-14. Real-time collaborative whiteboard — AI agents and humans edit the same board live over MCP.