Skip to main content
Glama

Create Board

create_board

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) seeds a kanban board. content imports initial items atomically: everything is validated FIRST and the board is created only if every item passes — on any invalid item you get a structured error naming its kind + index and NOTHING is created. autolayout: true (draw mode) fills in x/y for texts/images that omit them (deterministic masonry grid; explicit coordinates are never touched). lock: 'write'|'all' locks the board atomically with creation and returns the plaintext access_key ONCE — there is no recovery. The response's imported counts confirm what was created, ids returns the server-minted item ids per kind in the order you supplied them (index i of ids.texts is the id created for content.texts[i]; ids.columns is empty when the columns came from the template seed, and lanes have no id — they are keyed by board + lane index), and embed_url (the ?embed=1#<id> iframe view) is returned for any board readable without a key — it is omitted for lock:'all' boards, whose embed frame can't read the board anonymously. Prefer this over open_board + N per-item calls when you are building a whole board from scratch.

Tool call template

This tool declares no required parameters. Add optional parameters from the input schema as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {},
    "name": "create_board"
  }
}

Input Schema

NameRequiredDescriptionDefault
lockNoPIN-lock the board atomically at create time; the plaintext key is returned ONCE as `access_key`.
modeNoBoard mode. Defaults to 'draw'.
nameNoOptional shared board name (max 100 chars, whitespace collapsed); change later with `rename_board`.
authorNoAuthor tag stamped on every created item (e.g. 'ai:plai'). Defaults to 'ai:import'.
contentNoInitial board content, applied atomically at create time. Draw mode: `texts` [{x?, y?, content, color?, width?, postit?, diagram?, kind?, author?, sourceId?}], `lines` [{points, color?, anchors?, author?}] (alias `strokes`), `images` [{x?, y?, dataUrl, width, height, author?, sourceId?}]. Todo mode: `columns` [{title, lane?, color?, author?}] (array order = sort order), `tasks` [{columnIndex, name, description?, due_date?, priority?, assignee?, done?, color?, author?}] (columnIndex indexes into content.columns, or into the template-seeded columns when content.columns is empty), `lanes` [{lane, title, author?}], `colWidth`. Every item's optional `author` is its CREATOR tag (same 1-80 char [A-Za-z0-9:_-.] rule as elsewhere) and is never rewritten later — omit it to inherit the top-level `author`, or set it per item to preserve the original authorship when restoring somebody else's board. Item ids are ALWAYS minted server-side and returned in `ids`; you cannot choose them. To keep anchored strokes, give a text/image an optional `sourceId` (unique string, <=128 chars, write-only — never stored, never the row id) and reference it from `lines[].anchors.start.id` / `.end.id`: matching ids are rewritten to the minted id, unmatched ids are left as-is and render as a free stroke end. Kanban structures with a non-todo mode (or draw items with mode 'todo') are rejected with `content_mode_mismatch`. The combined input arrays may contain at most 2550 entries. At most 10 lane-title entries are accepted, every title must reference a lane used by a created column, and each lane index may be named AT MOST ONCE — a second entry for the same lane is rejected (naming that second entry's index) instead of collapsing last-write-wins, which would overwrite the first entry's author. `tasks[].done` must be a real boolean (or omitted/null for not-done): a truthy stand-in such as the string "false" is rejected rather than coerced, so a card is never imported as completed by accident. Standard per-board quotas also apply, and the 5 MB request-body cap is the real ceiling for image-heavy imports. A valid X-Import-Token selects higher REST/MCP and board-create rate tiers, but never changes these content limits.
templateNoStarter column set when mode is 'todo' and content.columns is empty/absent. Defaults to 'kanban'.
autolayoutNoDraw mode only: fill x/y for texts/images that omit them (deterministic masonry). Without it, items missing coordinates are rejected. No-op in todo mode.

Schema Changelog

Changes observed during successful MCP inspections.

  1. Changed1 schema field changed
    • addedInput schema / properties / name
      Added value: +{
      +  "description": "Optional shared board name (max 100 chars, whitespace collapsed); change later with `rename_board`.",
      +  "type": [
      +    "string",
      +    "null"
      +  ]
      +}
  2. Changed1 schema field changed
    • changedInput schema / properties / content / description
      Previous value: -"Initial board content, applied atomically at create time. Draw mode: `texts` [{x?, y?, content, color?, width?, postit?, diagram?, kind?}], `lines` [{points, color?, anchors?}] (alias `strokes`), `images` [{x?, y?, dataUrl, width, height}]. Todo mode: `columns` [{title, lane?, color?}] (array order = sort order), `tasks` [{columnIndex, name, description?, due_date?, priority?, assignee?, done?, color?}] (columnIndex indexes into content.columns, or into the template-seeded columns when content.columns is empty), `lanes` [{lane, title}], `colWidth`. Kanban structures with a non-todo mode (or draw items with mode 'todo') are rejected with `content_mode_mismatch`. The combined input arrays may contain at most 40 entries. At most 10 lane-title entries are accepted and every title must reference a lane used by a created column. Standard per-board quotas also apply. A valid X-Import-Token selects higher REST/MCP and board-create rate tiers, but never changes these content limits."New value: +"Initial board content, applied atomically at create time. Draw mode: `texts` [{x?, y?, content, color?, width?, postit?, diagram?, kind?, author?, sourceId?}], `lines` [{points, color?, anchors?, author?}] (alias `strokes`), `images` [{x?, y?, dataUrl, width, height, author?, sourceId?}]. Todo mode: `columns` [{title, lane?, color?, author?}] (array order = sort order), `tasks` [{columnIndex, name, description?, due_date?, priority?, assignee?, done?, color?, author?}] (columnIndex indexes into content.columns, or into the template-seeded columns when content.columns is empty), `lanes` [{lane, title, author?}], `colWidth`. Every item's optional `author` is its CREATOR tag (same 1-80 char [A-Za-z0-9:_-.] rule as elsewhere) and is never rewritten later — omit it to inherit the top-level `author`, or set it per item to preserve the original authorship when restoring somebody else's board. Item ids are ALWAYS minted server-side and returned in `ids`; you cannot choose them. To keep anchored strokes, give a text/image an optional `sourceId` (unique string, <=128 chars, write-only — never stored, never the row id) and reference it from `lines[].anchors.start.id` / `.end.id`: matching ids are rewritten to the minted id, unmatched ids are left as-is and render as a free stroke end. Kanban structures with a non-todo mode (or draw items with mode 'todo') are rejected with `content_mode_mismatch`. The combined input arrays may contain at most 2550 entries. At most 10 lane-title entries are accepted, every title must reference a lane used by a created column, and each lane index may be named AT MOST ONCE — a second entry for the same lane is rejected (naming that second entry's index) instead of collapsing last-write-wins, which would overwrite the first entry's author. `tasks[].done` must be a real boolean (or omitted/null for not-done): a truthy stand-in such as the string \"false\" is rejected rather than coerced, so a card is never imported as completed by accident. Standard per-board quotas also apply, and the 5 MB request-body cap is the real ceiling for image-heavy imports. A valid X-Import-Token selects higher REST/MCP and board-create rate tiers, but never changes these content limits."
  3. Added

TDQS

A4.9/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Goes well past the annotations: atomic all-or-nothing import with structured per-item errors and nothing created on failure, one-time non-recoverable access_key for lock, embed_url omitted for lock:'all', quota and 5 MB body caps, and X-Import-Token rate-tier effects. These are exactly the side-effect and failure-mode details annotations cannot express.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the core action and the sibling routing, then dense but purposeful detail. It is long and packs many clauses into single sentences (content, ids, embed_url), which costs some scannability, but almost nothing is filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 7-parameter, nested-object create tool with no output schema, it covers creation semantics, failure behavior, quota limits, and even the response shape (imported, ids, access_key, embed_url). Nothing an agent needs to invoke it correctly is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is already 100%, yet the description still adds meaning the schema does not: sourceId-to-anchor id rewriting semantics, index alignment of ids.texts to content.texts, empty ids.columns on template seeds, id-less lanes, strict-boolean rejection of tasks[].done, and the 2550-entry/10-lane rules. It compensates far beyond the baseline.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('Create a fresh board') and immediately narrows scope: blank draw board by default, kanban with mode:'todo'. It explicitly contrasts with the open_board + per-item path, so an agent can distinguish it from every sibling without opening a schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives explicit when-to-use ('Prefer this over open_board + N per-item calls when you are building a whole board from scratch') plus mode-driven selection guidance (draw vs todo, template seeding). The alternatives and the condition that selects them are both named.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Try in Browser

Glama MCP Gateway

Add one secure layer between your agents and this server.