More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Livingboard

    1

    Sketch on a shared whiteboard. Your agent reads it, draws back editable diagrams and tables, and keeps board and code in sync.

    Free

    Security scanned
    Livingboard

    Livingboard

    Example session with this skill installed

    Open a whiteboard called agensi-demo, draw how Livingboard works, and add a table of its packages.

    • Read your context and instructions
    • Compiled the livingboard

    Summary

    Opened board agensi-demo at http://localhost:3333/?p=personal_projects-668520&board=agensi-demo and added two editable drawings: a diagram of how Livingboard works and a table of its packages. The first screenshot on this page shows the result.

    What the agent did

    StepToolResult
    1open_boardCreated the board in .livingboard/boards/agensi-demo.ydoc, readable copy in agensi-demo.md
    2board_overviewEmpty board, effort medium, no drawings yet
    3draw_diagramdrawingId: d_brjiy7t02p2g, 18 elements
    4draw_tabledrawingId: d_g6j8n8hs2p81, 19 elements
    5get_board_imageChecked the render, 1020×587 px

    On the board

    How Livingboard works

    flowchart LR
      B[Browser board] <-->|Yjs live sync| S[Livingboard server]
      S <-->|MCP| A[Coding agent]
      S -->|saves| F[(.livingboard/boards)]
      A -->|edits| C[Project code]
    

    Packages

    PackageJob
    sharedDocument schema, types, Yjs keys
    serverSync, segmentation, MCP, persistence
    webExcalidraw, AI overlay, panel, views
    livingboardnpm package: bundled server and CLI

    In the repo

    Livingboard wrote this readable copy next to the board, so it shows up in diffs:

    
    # agensi-demo
    
    > Livingboard board of personal_projects, written by Livingboard on every change: edit the board, not this file (`/whiteboard agensi-demo` in Claude Code).
    
    ## Claude's drawings
    
    - **How Livingboard works** (diagram): Browser board · Livingboard server · Coding agent · .livingboard/boards · Project code · Yjs live sync · MCP · saves · edits
    - **Packages** (table): Package · Job · shared · Document schema, types, Yjs keys · server · Sync, segmentation, MCP, persistence · web · Excalidraw, AI overlay, panel, views · livingboard · npm package: bundled server and CLI · Packages
    

    Next steps

    • Change a cell in the table: the agent receives it as drawingEdits and updates the project.
    • Write @claude ... next to a drawing: the answer appears on the board.
    • When the project changes, the agent redraws the same drawing with replace.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Livingboard is an open-source whiteboard your coding agent can read and draw on. You sketch screens, flows and ideas; the agent reads them, builds, and puts back on the board what it did.

    This skill tells the agent when and how to use the board. The board itself is the free Livingboard MCP server (MIT), which you install separately. The skill shows you the commands and asks before installing anything.

    What it does

    • Reads what you draw: sketches, handwriting and arrows, through the agent's own vision.
    • Draws back: screens, tables, charts and Mermaid diagrams, made of normal Excalidraw elements you can move and edit.
    • Keeps the board current: every drawing has an ID, so the agent redraws it in place instead of piling up copies.
    • Treats your edits as requests: change a cell in the agent's table and the agent updates the project to match.
    • Lives in your repo: boards are saved in .livingboard/boards/, with a readable .md copy that shows up in diffs.

    How it works

    1. The agent checks that the open_board tool is available. If not, it shows you the install commands and what they change, and waits for your yes.
    2. It opens the board and gives you the URL.
    3. It follows the working rules the server returns, and draws what it builds or decides.
    4. It reads your changes with wait_for_changes and updates the project.

    When to use it

    Best for screens, flows, architecture and plans, where position carries meaning. For bugs, refactoring and precise rules, text is still faster: the board gives the chat a map, it doesn't replace it.

    About the screenshots

    The first screenshot is the board from the demo session on this page. The others come from the project's README: a real board, with the agent's side scripted for the recording through the same MCP tools.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Agents & Orchestration.

    Requires installing the free livingboard npm package. Tested on Claude Code only. One agent per board at a time. Sketch recognition depends on the agent's vision. Many large images make a board heavy to load. Arrows drawn by the agent are not bound to shapes. The board page loads a font from the esm.sh CDN.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 12 days ago

    • Free with an Agensi account

    Software
    livingboard MCP serverNode.js 22+A web browser

    Permissions

    Terminal / Shell
    Read Files
    Network Access
    Write Files
    Browser

    File Scopes

    .livingboard/**
    ~/.livingboard/**
    ~/.claude/settings.json
    ~/.claude/skills/whiteboard/**

    Shell: only for the install commands, after the user says yes. Read/write files: the agent updates the project to match the board; the server saves boards in .livingboard/ and its data in ~/.livingboard/; on Claude Code, `livingboard install` edits ~/.claude/settings.json and adds a skill. Browser: the board opens in a tab. Network: npm install, a local server on 127.0.0.1, and the Excalidraw font from esm.sh. Board content stays on the computer unless --lan is turned on.

    Listed12 days ago

    What's inside

    Frequently Asked Questions

    Yes. The skill is free here, and the Livingboard server it relies on is free and open source under the MIT license.

    Node.js 22+ and the livingboard npm package. On Claude Code, run npm install -g livingboard and then livingboard install. The skill shows you these commands and asks before running them.

    It is built and tested on Claude Code. The board talks plain MCP, so other clients can add livingboard mcp as a stdio server, but that path is untested and has no /whiteboard shortcut or change hook.

    It registers the MCP server at user scope, adds a /whiteboard skill and adds a UserPromptSubmit hook to ~/.claude/settings.json. livingboard uninstall removes all three. Boards in your projects stay.

    Board files and the server stay on your machine, and the server listens only on 127.0.0.1 unless you turn on --lan. What the agent reads goes to its model provider like any other context. The page also loads a font from esm.sh.

    Yes. Everything it draws is made of normal Excalidraw elements. If you change a table cell or a label, the agent receives the change and updates the project to match.

    New in Agents & Orchestration

    Free