add_tag
ChatGPTAttach a tag, also called a label, to one or more widgets. This is how a widget is labeled or classified (including sentiment or status) without changing its text, which stays the member's own content. If tag_id is provided, attaches that existing tag to the widgets. If tag_id is omitted, creates a new tag (text is required); the optional color_name selects a curated palette entry, and the optional icon_id gives the new tag an icon (get the id from search_icons). Use update_tags to rename, recolor, or change the icon of an existing tag, and delete_tags to remove a tag definition from the mural entirely. Canvas Host loads the mural on demand. A call that timed out or never answered may already be saved, and repeating it duplicates the change.
add_template_to_canvas
ChatGPTAdd a Mural template onto the canvas. The Mural app inserts the widgets itself, so the full layout (text, shapes, clusters, tables, photos, connectors) lands with full fidelity in one undoable action, alongside existing content — nothing is replaced. By default the template lands to the right of existing content (canvas origin when empty); pass both x and y to place its top-left corner explicitly. Returns the created widget_ids; fill the template in with the normal read and edit tools. Only templates from Mural's built-in library (including partner methods such as LUMA) can be added; workspace or custom template ids fail with an error. This tool has no Canvas Host path yet: it runs inside the Mural app the user has open on this mural, and fails with BRIDGE_NO_TAB_FOUND when none is connected. A call that timed out or never answered may already be saved, and repeating it duplicates the change.
add_to_outline
ChatGPTAdd existing canvas widgets to the mural's presentation outline, at the end of it, in the order given. Use it whenever a request says which widgets should be the slides of a presentation, and in what order — the given order is the order they are added in. This is the one and only tool for putting something in the outline — use it whether you add one widget or many; they are all added in a single call. Outline items are ordinary widgets rather than separate objects, so this tool takes the ids of widgets that already exist on the canvas; it creates nothing. Areas are the usual choice (an area in the outline is what a presentation steps through as a slide), but stickies, shapes, titles, text, images and files can all be outline items. Groups, comments, connectors, tables and table cells cannot, matching in-app behavior; nor can a widget that is already in the outline, which is reported as a per-widget failure rather than moved. Adding to the outline requires the current participant to be a facilitator. The tool resolves their role itself and rejects the whole batch when they are not one. The response is a uniform envelope: status: "ok" (all added — success: true, with an added count), status: "partial" (some added, the rest in failed — success: false), or status: "error" (nothing added — success: false with an error_code). Retry only the failed entries. Canvas Host loads the mural on demand.
check_usage
ChatGPTReports how much of today's Mural tool-call allowance you have used: the daily total, any shared limits on groups of tools (for example screenshots), your most-used tools, and when the counts reset (00:00 UTC). Calling this tool is free and does not count toward any limit. Calls that were refused for being over a limit still count, so "used" can be higher than "limit". If "exempt" is true, the limits do not apply to you.
create_areas
ChatGPTCreate area (frame) widgets on the canvas. Mural draws the most recently created widget on top, so an area created after the widgets meant to sit inside it covers them; within one call, later areas draw over earlier ones. Areas act as containers, but a widget only becomes a child that moves with the area when you set its parent_id to the area — pass parent_id when creating that widget (e.g. via create_shapes/create_stickies) or call move_widgets_to_area afterwards; placing a widget inside the bounds alone does not parent it. Size each area generously so its planned contents fit, and keep the top edge clear so the area's name stays legible. Pass areas as a list — always a list, even for one area. Each item is an object with numeric x, y, width, height, and an optional title. The response reports each area's id, position, and size, plus a status of ok/partial/error, success, and any failures in failed (each with the reason it failed). At most 100 areas per call. Canvas Host loads the mural on demand. A call that timed out or never answered may already be saved, and repeating it duplicates the change.
create_connectors
ChatGPTDraw connectors (arrows) on the canvas. This is the one and only connector-creation tool — use it whether you need one connector or many (e.g. wiring up a whole flowchart); they are all created in a single call. Pass connectors as a list — always a list, even for a single connector (then it is a one-element list). Each item connects a source widget to one target and is one of two shapes: widget → widget {"start_widget_id": string, "end_widget_id": string} — the arrow is anchored to both widgets and stays attached when either moves. widget → point {"start_widget_id": string, "end_x": float, "end_y": float} — the tail is anchored to the source widget; the arrowhead floats freely at the given canvas coordinate (use this for an open-ended flow, a pending connection, or to point at empty space). Give exactly one target per connector (either end_widget_id or both end_x and end_y, not both). Each item may also set an optional arrow_type: 'straight' (direct line, default), 'orthogonal' (right-angle elbow), 'curve' (smooth curve), or 'bezier' (cubic bezier). Each item may also set an optional text: plain text shown on the connector, auto-centered (not Markdown). On a Mural build without connector label support the connector is created without it; the response does not confirm the label, so read it back (list_widgets) if it matters. The response is a uniform envelope: status: "ok" (all created — success: true, each connector's id in connectors), status: "partial" (some created, the rest in failed — success: false), or status: "error" (none created — success: false with an error_code). Each failed entry carries the reason it failed. At most 100 connectors per call. Canvas Host loads the mural on demand. A call that timed out or never answered may already be saved, and repeating it duplicates the change.
create_icons
ChatGPTPlace Noun Project icons (MURAL sticker widgets) on the canvas. Use the id from a search_icons result as each item's noun_project_id, and pass that result's tags so the icon stays identifiable in later canvas reads. Pass icons as a list — always a list, even for one icon; list order is back to front, later icons on top. Each item is an object with a noun_project_id, numeric x, y, and optional width (default 100), height (default 100), color (hex tint), tags (list of strings), and parent_id (an area to nest the icon in). The response reports each icon's id, position, size, and its noun_project_id/tags, plus a status of ok/partial/error, success, and any failures in failed (each with the reason it failed). At most 100 icons per call. Canvas Host loads the mural on demand. A call that timed out or never answered may already be saved, and repeating it duplicates the change.
create_mural
ChatGPTCreate a new blank mural (whiteboard) inside a specific room. Prefer passing room_id when you have it (it is in the room URL and identifies the room unambiguously, since room names are not unique). Otherwise pass workspace_name and room_name as human-readable names, not IDs; when the exact names are unknown, list_workspaces resolves the workspace name and list_rooms resolves the room name. A workspace_id from either of those tools can stand in for workspace_name. On success, returns mural_id. Select the new mural id and Canvas Host loads it on the first canvas operation. A call that timed out or never answered may already be saved, and repeating it duplicates the change.
create_shapes
ChatGPTBatch-create shape widgets; pass shapes as a list (one or many). Shapes are visual backdrops, not containers: a shape is never a widget's parent, so widgets placed over it do not move with it. List order is back to front: later items draw on top, also over what is already on the board, so list backdrops and outer boxes first. Areas (create_areas) group widgets that move together. Each item has numeric x, y (top-left), width, height, and a shape_type: a smart (snake_case, preferred) or legacy (PascalCase) name, all listed in the shapes parameter. Common picks: rectangle, ellipse, rounded_square, star, cloud, speech_bubble_center; process, decision, start, end, data, document for flowcharts. Concepts with no name of their own: a flowchart cylinder is database, a rounded rectangle is rounded_square, an oval is ellipse, and a true circle is legacy Circle. Optional per item (omit for defaults): background_color, stroke_color (hex), stroke_size (px), stroke_style ('', '.', '-', '. ', 'solid', 'dotted'; also 'dashed', 'dotted-spaced'); rotation (deg); text (Markdown) with text_color, font_size, font_family, text_align ('left'|'center'|'right'), vertical_align ('top'|'middle'|'bottom'); locked, hidden, title, instruction, parent_id (containing area). Markdown in text: bold, italic, lists, links; headings render bold; no code, quotes or rules. For opacity, use the hex alpha channel. A legacy name may start lowercase (circle for Circle); any other shape_type must match exactly. An unknown name rejects the whole call (nothing is created); the error lists the valid names. The response gives each shape's id, position, size, a status of ok/partial/error, success, and per-item reasons in failed. At most 100 shapes per call. Canvas Host loads the mural on demand. A call that timed out or never answered may already be saved, and repeating it duplicates the change.
create_stickies
ChatGPTCreate sticky notes on the canvas. This is the one and only sticky-creation tool — use it whether you need one sticky or hundreds (e.g. turning a list of items, tickets, or ideas into stickies); they are all created in a single call. Text is the member's own content; classification belongs on a tag via add_tag. Pass stickies as a list — always a list, even for a single sticky (then it is a one-element list). Each item is an object {"x": float, "y": float, "text"?: string (Markdown — plain text is valid Markdown), "background_color"?: hex like '#fcf281'}. Whole-widget restyle (bold/color/…) is applied after creation via update_widgets. Supported Markdown in text: bold, italic, bulleted/numbered lists, and links; headings render as bold text. Code blocks, blockquotes, and --- rules are not rendered. Give each sticky the position you want — any sticky that would collide with existing content or another sticky in this batch is nudged to the nearest free spot, so a rough grid is fine. Areas and shapes never block: stickies aimed inside them stay put. Pass parent_id to place every sticky inside an area (they become its children and move with it); x/y are given as absolute canvas coordinates at creation, but once parented they are stored and read back area-relative. The response reports each sticky's final position, size, and id (a nudged sticky also carries its original coordinates as requested_x/requested_y), plus a status of ok/partial/error, success, and any failures in failed. A failure carrying the widget's id means that sticky was created but its text did not land: fix it with update_widgets rather than retrying, which would leave the blank one behind. A failure without one was never created, so retry it. At most 100 stickies per call. Canvas Host loads the mural on demand. A call that timed out or never answered may already be saved, and repeating it duplicates the change.
create_table
ChatGPTCreate a table widget on the canvas and, optionally, populate its cells in one call. Specify rows and columns (each >= 1) and pass cell_content as a row-major 2D array to fill cells, with the header row first. Cell content is Markdown; supported: bold, italic, bulleted/numbered lists, and links; Code blocks, blockquotes, and --- rules are not rendered. Rows auto-size to fit their text so content never overflows; column_widths, row_heights, and cell_font_size override the sizing. Pass parent_id to nest the table inside an area so it moves with the area. Canvas Host loads the mural on demand. A call that timed out or never answered may already be saved, and repeating it duplicates the change.
create_textboxes
ChatGPTCreate textbox (a.k.a. paragraph) widgets on the canvas. In MURAL's UI this widget is labelled 'Paragraph'. It handles requests to add paragraphs, blocks of body text, or fixed-width text widgets that aren't headings/titles or stickies. For auto-resizing headings use create_titles; for sticky notes use create_stickies. Text is the member's own content; classification belongs on a tag via add_tag. Pass textboxes as a list — always a list, even for one textbox. Each item is an object with numeric x, y plus optional text, width, height, font_size, font_color (hex), and parent_id (an area to nest it in). width is honored, but height auto-fits to the text (the read-back height reflects the content, not the value you passed). text is Markdown (plain text is valid Markdown). Supported Markdown: bold, italic, bulleted/numbered lists, and links; headings render as bold text. Code blocks, blockquotes, and --- rules are not rendered. Use inline Markdown only to emphasize part of the text. To emphasize the whole textbox, set the restyle flags bold, italic, strike, underline to true and leave text plain — do not wrap the entire string in Markdown. Textboxes are created exactly at the requested position. List order is back to front: later items draw on top. The response reports each textbox's id, position, and size, plus a status of ok/partial/error, success, and any failures in failed (each with the reason it failed). At most 100 textboxes per call. Canvas Host loads the mural on demand. A call that timed out or never answered may already be saved, and repeating it duplicates the change.
create_titles
ChatGPTCreate title widgets on the canvas. Titles are MURAL's section-headline widget — visually similar to a textbox but with an auto-resizing width by default and decoration props (corner radius, custom border, shadow) that textboxes don't have. Use titles for slide headings, section banners, and other prominent labels. Text is the member's own content; classification belongs on a tag via add_tag. Pass titles as a list — always a list, even for one title. Each item is an object with numeric x, y plus optional styling/state fields; omit them for SDK defaults (large font, no border, no shadow). Text: text (Markdown — plain text is valid Markdown), font_size, font_family, font_color (hex), text_align ('left'|'center'|'right'). Supported Markdown in text: bold, italic, bulleted/numbered lists, and links; headings render as bold text. Code blocks, blockquotes, and --- rules are not rendered. Use inline Markdown only to emphasize part of the text. To emphasize the whole title, set the restyle flags bold, italic, underline, strike to true and leave text plain — do not wrap the entire string in Markdown. Box/decoration: width, height, fixed_width (pin to width; ignored without a width), background_color, border, border_color, border_thickness, corner_radius, shadow. Transform: rotation. State/metadata: locked, hidden, title, instruction, parent_id. Titles are created exactly at the requested position. List order is back to front: later items draw on top. The response reports each title's id, position, and size, plus a status of ok/partial/error, success, and any failures in failed (each with the reason it failed). At most 100 titles per call. Canvas Host loads the mural on demand. A call that timed out or never answered may already be saved, and repeating it duplicates the change.
delete_tags
ChatGPTDelete tag definitions from the mural by id, also detaching them from any widgets. This is the one and only tag-deletion tool — use it whether you delete one tag or many; they are all removed in a single call. Use remove_tag to detach a tag from specific widgets while keeping the definition. Pass tag_ids as a list — always a list, even for a single tag (then it is a one-element list). Deleting a tag id that does not exist (or was already deleted) is treated as a successful no-op. The response is a uniform envelope: status: "ok" (all deleted — success: true, with a deleted count), status: "partial" (some deleted, the rest in failed — success: false), or status: "error" (nothing deleted — success: false with an error_code). Retry only the failed entries. Canvas Host loads the mural on demand.
delete_widgets
ChatGPTDelete widgets from the canvas by id. This is the one and only widget deletion tool — use it whether you need to delete one widget or many; they are all removed in a single call. Works for any widget type (sticky, area, text, shape, etc.). Pass widget_ids as a list — always a list, even for a single widget (then it is a one-element list). The ids come from list_widgets. Deleting an area removes the widgets inside it too by default; pass delete_contents=false to delete only the areas and keep their widgets (the flag applies to every area in the batch). This action cannot be undone through the MCP server. The response is a uniform envelope: status: "ok" (all deleted — success: true, with a deleted count), or status: "error" (nothing deleted — success: false with an error_code; when the delete call itself fails, every id is also listed in failed). The deleted count reflects the ids submitted, not a check that each existed — an unknown or already-deleted id is counted and not reported as a failure; list_widgets shows which ids currently exist. Canvas Host loads the mural on demand.
get_canvas_overview
ChatGPTGet a compact, token-bounded overview of a canvas: total widget count, counts by type, overall bounding box, top-level widget count, and a list of areas with their titles. Answers structural questions about a canvas ("what types of widgets exist?", "how big is it?", "what areas exist?") — it returns counts and metadata, not widget content, and costs a fraction of list_widgets or get_document_tree. Canvas Host loads the mural on demand.
get_canvas_screenshot
ChatGPTCapture the entire Mural canvas as a single image. Returns an MCP image content block containing the full-canvas PNG. Use only when you need a full-canvas view — overall board layout, holistic visual overview, or content spanning the entire canvas. Prefer list_widgets for structured data or get_viewport_screenshot for targeted visual detail, as those are faster and cheaper. Canvas Host exports from the current synchronized mural state.
get_document_tree
ChatGPTGet a hierarchical document tree of canvas widgets. Areas contain their child widgets in a 'children' array. Top-level widgets (not inside any area) appear at the root. Each node carries the same per-widget fields as list_widgets (controlled by view) plus parent_id and children. For high-level structure questions ("what areas exist?", "what types of widgets are in this mural?"), get_canvas_overview returns counts and metadata without fetching the tree. This tool provides the full board tree or a subtree you need to traverse — e.g. 'show me everything nested under the "Planning" area'. For one widget's direct relations (children, arrows, comments), get_widget_relations is faster and scoped to a single widget. When using root_id, resolve names to ids via get_canvas_overview. Prefer view="compact" for structure or content queries — it's ~half the payload of full. Use view="full" (the default) when you need geometry, color, or lock state. Canvas Host loads the mural on demand.
get_mural_access_info
ChatGPTGet the current sharing permissions for the Mural — the access level granted to visitors and to workspace members. Returns {visitors, workspace_members} where each value is one of 'none', 'read', or 'write'.
get_mural_info
ChatGPTGet metadata for the current Mural (board), such as identifiers and title. Use when the agent needs mural context (which board is open). Response uses snake_case fields.
get_skill
ChatGPTRead the full text of a skill guide by its skill_id. Valid skill_ids are those returned by list_skills.
get_viewport_screenshot
ChatGPTCapture a raster image of the user's current viewport, or of an explicit Mural canvas region. Without region the tool captures what the user sees in the Mural app they have open on this mural, and fails with BRIDGE_NO_TAB_FOUND when none is connected. With region the image comes from the Canvas Host export worker. For structured content, prefer list_widgets with aabb or list_widgets_near; they are faster and need no vision. Set max_output_dimension to the longest image side (in pixels) the caller's vision model can tokenize. Override output_width/output_height only when you need a specific output box; both values must be <= max_output_dimension. The headless worker preserves the region aspect ratio within that box. Returns an MCP image content block followed by a JSON text block with fidelity metadata - exported region and effective_pixels_per_unit. A viewport capture reflects the Mural app's current render and can briefly lag a just-created, moved, or deleted widget; a structured read (list_widgets_in_viewport) reflects such edits immediately. That render also omits the text of a widget someone is currently typing in, so a blank card is not evidence of a failed write: list_widgets and get_widget_by_id are authoritative for text, and list_selected_widgets flags such a widget with editing: true.
get_widget_by_id
ChatGPTGet one widget's full state by id, in the SDK's raw camelCase shape (backgroundColor, parentId, x/y) — this differs from the snake_case that list_widgets and get_document_tree return, so prefer those when you want the normalized shape. For connectors, startRefId is the source widget and endRefId is the destination (the widget the arrowhead points at), consistent with create_connectors and update_widgets. Returns {widget: null} for an unknown id. Canvas Host loads the mural on demand.
get_widget_relations
ChatGPTGet the widgets related to a single widget, as structured data. Given a widget_id, this returns five relation sets scoped to that widget: connected_arrows — arrows attached to the widget children — widgets directly nested in it (area/table members) descendants — all widgets nested beneath it, transitively related_comments — comments anchored to it parts_of — containers this widget is a member of Answers relationship questions ('what's connected to this shape?', 'what's inside this area?', 'what comments are on this sticky?') when you have the widget id, more directly than get_document_tree or list_widgets. Each set is [] when the widget has no relations of that kind. An unknown widget_id returns an error (not empty sets). Canvas Host loads the mural on demand.
get_widgets_screenshot
ChatGPTCapture a raster screenshot of specific widgets by id so you can see them — photos, images, drawings, icons, diagrams, handwriting, or any widget whose visual appearance or spatial layout matters. For text, ids, types, or positions alone, list_widgets is faster and needs no vision. Set max_output_dimension to the longest image side (px) your vision model can tokenize; override output_width/output_height only for a specific output box, both <= max_output_dimension (the headless worker preserves the selection aspect ratio within that box). Returns an image block plus metadata (region, effective_pixels_per_unit); a low effective_pixels_per_unit means text may be illegible, so screenshot fewer or closer-together widgets. When none of the ids are found the call errors, and ids that aren't found are silently omitted from the image — get_canvas_screenshot covers the whole board. A container id — an area or a table — exports with everything nested inside it, plus anything else overlapping its bounds. With Canvas Host, the backend export worker resolves each widget's absolute bounds and renders the explicit selection directly.
invite_users_to_mural
ChatGPTInvite people to collaborate on a mural by email. Each invitee is granted either 'view' (read-only) or 'edit' access. Requires a mural you have permission to manage. Per-invitee problems (invalid email, already a member, blocked by company policy) come back in the 'rejected' list rather than failing the whole call. Optionally include a personal 'message' and control whether an invitation email is sent with 'send_email'. A call that timed out or never answered may already be saved, and repeating it duplicates the change.
list_outline
ChatGPTList the mural's presentation outline — the ordered items shown in the outline panel and stepped through in presentation mode. Returns one entry per item with position, widget_id, widget_type, title, and is_hidden, in outline order. Outline items are ordinary canvas widgets (most often areas, but stickies, shapes, images and files can all be in the outline), so each widget_id also works with the other canvas tools. position is a 0-based ordinal over the items returned here, not a stored property of the widget: it is contiguous even though the underlying order values are not. An empty title means the item is unnamed — the outline panel displays such an item as "Unnamed <type>", for example "Unnamed area". Returns an empty list when the mural has no outline. Canvas Host loads the mural on demand.
list_rooms
ChatGPTList the rooms inside a MURAL workspace, excluding the ones the user is not a member of. Returns each room's exact name and id, which create_mural uses to resolve a room by name, plus is_member, can_create_murals, and type. create_mural needs a room with can_create_murals true; is_member is not enough — a member with access to only some of a room's murals, or without create permission, is still rejected. A workspace also contains rooms the user can see but is not a member of; create_mural rejects those, so they are left out unless include_all_rooms is set and hidden_non_member_rooms reports how many were withheld. Only a room reported as not a member is withheld: is_member null means the workspace did not report it readably, and those rooms are listed rather than hidden.
list_selected_widgets
ChatGPTList the currently selected widgets on the canvas. Returns per-widget fields controlled by view (see view parameter); parent_id / children are not included — selection is flat. Use when the user refers to 'selected' items or the agent needs what is highlighted. Reads the live selection in the Mural app the user has open on this mural. A widget the user is currently typing in carries editing: true on top of the view fields, in either view; its text is missing from a get_viewport_screenshot image taken without a region, so get_widget_by_id is the reliable read for it; get_canvas_screenshot renders it. This tool has no Canvas Host path yet: it runs inside the Mural app the user has open on this mural, and fails with BRIDGE_NO_TAB_FOUND when none is connected.
list_skills
ChatGPTList the skill guides available on this MCP server. Returns one [skill_id, description] pair per skill. Pass a skill_id to get_skill to read that guide's full text.
list_tags
ChatGPTList the tags defined on the mural, with the widget ids each tag is attached to. Returns name, color, optional icon, and widget_ids per tag. Surfaces existing tags (reusable with add_tag) and the widgets carrying a specific tag. Canvas Host loads the mural on demand.
list_widgets
ChatGPTList widgets on the canvas (stickies, shapes, text, etc.) as a semantic snapshot. This is the broad, whole-board fallback — before reaching for it, check whether a narrower, cheaper tool answers the actual question (this tool's cost grows with the widget count; the others below do not): • counts, types, size, or the list of areas → get_canvas_overview (cheapest; no widget content) • one widget's arrows, children, or containing area/table → get_widget_relations • the nesting hierarchy (what is inside what) → get_document_tree • widgets around a given widget → list_widgets_near • what is on the user's screen right now → list_widgets_in_viewport • the widgets the user has selected → list_selected_widgets • one widget you already have the id for → get_widget_by_id Use list_widgets when you genuinely need every widget (or every widget in a region): omit aabb to list the whole board, or pass an aabb region to list only the widgets in that rectangle. Prefer view="compact" (widget_id, widget_type, text) for content queries like 'find the sticky about X' — it's ~half the payload of full. Use view="full" (the default) when you need geometry, color, or lock state. Pass widget_types to return only certain kinds of widget (e.g. just areas or connectors). Canvas Host loads the mural on demand.
list_widgets_in_viewport
ChatGPTList the widgets currently visible in the user's viewport, as structured data (not an image). Best when the answer is about content: what's on screen, summarizing the current view, or the text, types, ids, or positions of visible widgets; it is faster and needs no vision. get_viewport_screenshot fits instead when visual appearance or spatial layout matters and structured data cannot convey it. Returns only the widgets in the visible region, not a full-board listing — for the whole board use list_widgets. May return nothing if the viewport is blank or zoomed onto empty canvas, which does NOT mean the board is empty. Per-widget fields are controlled by view (default "full"; use "compact" — widget_id, widget_type, text — for lighter content queries). This tool has no Canvas Host path yet: it runs inside the Mural app the user has open on this mural, and fails with BRIDGE_NO_TAB_FOUND when none is connected.
list_widgets_near
ChatGPTList the widgets near an anchor widget, as structured data. Given an anchor widget_id and a radius in canvas pixels, this reads the anchor's bounding box, expands that box by radius px on each side (a box, not a circle), and returns all widgets that overlap the expanded region — including partial overlaps — with the anchor itself excluded. Use this to answer proximity questions ('what's next to this sticky?', 'what surrounds this shape?') without reading the whole board; for the entire canvas use list_widgets. Returns {"widgets": []} when nothing else is in range. An unknown widget_id returns an error (not an empty list).Canvas Host loads the mural on demand.
list_workspaces
ChatGPTList all MURAL workspaces the current user has access to. Returns each workspace's exact name and id. When creating a mural by name, create_mural locates the workspace from either the workspace_name or the id returned here, passed as workspace_id.
lock_widgets
ChatGPTLock widgets on the canvas by id. This is the one and only locking tool — use it whether you lock one widget or many; they are all locked in a single call. Pass widget_ids as a list — always a list, even for a single widget (then it is a one-element list). lock_type applies to the whole batch; there are two kinds of lock: standard — any member can unlock it later. facilitator — only facilitators can unlock it later. The lock kind depends on the user's role: facilitators can apply either a standard or a facilitator lock, while non-facilitators can apply only a standard lock. The tool resolves the current participant's role itself and rejects a facilitator lock when they are not a facilitator. Locking a group also locks its children, matching in-app behavior. Locking an area locks only the area itself, not its children. Locking a table locks the table and its table cells. The response is a uniform envelope: status: "ok" (all locked — success: true, with a locked count), status: "partial" (some locked, the rest in failed — success: false), or status: "error" (nothing locked — success: false with an error_code). Retry only the failed entries. Canvas Host loads the mural on demand.
move_widgets_to_area
ChatGPTMove widgets into areas, making each a child of its target area so it moves with the area when the area is repositioned. This is the one and only move-to-area tool — use it whether you move one widget or many. Pass moves as a list; each item is {"widget_id": string, "area_id": string}. A single move is a one-element list ([{"widget_id": ..., "area_id": ...}]). To move many widgets into one area, repeat that area_id across the items. Widgets are placed at the area's center, spiralling outward to avoid stacking on existing children or on each other. Widget ids come from list_widgets or get_document_tree; area ids also appear in get_canvas_overview. Unknown widget/area ids, or a target that is not an area, are rejected per item and reported in the response's failed array; the rest of the batch still applies. The response is a uniform envelope: status: "ok" (all moved — success: true), status: "partial" (some moved, the rest in failed — success: false), or status: "error" (none moved — success: false with an error_code). Retry only the failed entries. Canvas Host loads the mural on demand.
remove_from_outline
ChatGPTRemove items from the mural's presentation outline. This is the one and only tool for taking something out of the outline — use it whether you remove one item or many; they are all removed in a single call. Removing every item is how an outline is cleared. Outline items are ordinary widgets, so this only takes them out of the outline: the widget stays on the canvas untouched. A widget that is not currently in the outline is reported as a per-widget failure rather than silently ignored. Removing an item also un-hides it. An outline item can be hidden from the canvas while it is in the outline; taking it out of the outline makes it visible again, because a hidden widget outside the outline would be unreachable. Removing from the outline requires the current participant to be a facilitator. The tool resolves their role itself and rejects the whole batch when they are not one. The response is a uniform envelope: status: "ok" (all removed — success: true, with a removed count), status: "partial" (some removed, the rest in failed — success: false), or status: "error" (nothing removed — success: false with an error_code). Retry only the failed entries. Requires a live browser tab connected to the bridge.
remove_tag
ChatGPTDetach a tag from one or more widgets. The tag definition itself stays; use delete_tags to remove a tag from the mural entirely. Canvas Host loads the mural on demand.
rename_outline_item
ChatGPTRename items in the mural's presentation outline — the label the outline panel shows for an item, which is the widget's title. This is the one and only tool for renaming outline items — use it whether you rename one item or many; they are all renamed in a single call. Pass renames as a list; each item is {"widget_id": string, "title": string}. A single rename is a one-element list. Widget ids come from list_outline. This tool only renames widgets that are currently in the outline; a widget outside it is reported as a per-widget failure. Renaming a widget that is not an outline item is what update_widgets does, and the two are not interchangeable. Renaming an outline item requires the current participant to be a facilitator. The tool resolves their role itself and rejects the whole batch when they are not one. An empty title clears the item's name rather than being rejected. The outline panel then displays the item as "Unnamed <type>", for example "Unnamed area", while the stored title is empty — which is what list_outline reports. The response is a uniform envelope: status: "ok" (all renamed — success: true, with a renamed count), status: "partial" (some renamed, the rest in failed — success: false), or status: "error" (nothing renamed — success: false with an error_code). Retry only the failed entries. Requires a live browser tab connected to the bridge.
search_icons
ChatGPTSearch the Noun Project icon library. Returns matching icons, each with `id (pass to create_icons as an item's noun_project_id), tags (descriptive keywords for the icon; the first is the most representative), and preview_data_url (base64 PNG — inspect to pick the best match; if preview_failed` is true, rely on tags instead).
search_murals
ChatGPTFind murals by title across every workspace the user belongs to. Matching covers the mural's title alone — content written on the canvas is not indexed, so a phrase copied off a sticky finds nothing. Whole title words match in any order, and the query's last word also matches as a prefix — 'road' finds 'Roadmap', while 'road map' does not, because only the last word is prefix-matched. One matching word is enough, so extra words widen the results instead of narrowing them; a single distinctive word beats a remembered full title. A fragment from the middle of a word matches nothing ('ural' misses 'Mural'), and tolerance for a misspelling is not guaranteed, so an empty result is worth retrying with a shorter word rather than a different spelling. Returns murals — each with mural_id, title, status ('active' or 'archived'), workspace_id, workspace_name, room_id, updated_on (epoch milliseconds), member_url and thumbnail_url — plus count. Archived murals are searchable and come back alongside live ones, so status is worth reading before offering a result. workspace_id is the only way to narrow a search. has_more: true means the page came back full and more may exist; raising limit is the only way to see further, up to 25. A mural_id from the results goes straight into any canvas tool, or into select_mural to pin it for the session.
search_templates
ChatGPTSearch Mural's built-in template library (including partner methods such as LUMA). Keyword search over title and description via query; omit query to browse. Returns matches with template_id and public_hash — pass both to add_template_to_canvas to insert one. Page with offset when next_offset is present. Keyword search inspects at most 100 matches; truncated: true on the last page means results were cut off at that cap — refine query to see the rest.
select_mural
ChatGPTDiscover or set the active mural for this MCP session. Call with no arguments to list candidates; call with `mural_id to make a specific mural the active selection. Not needed when the request already names a mural id: every canvas tool accepts mural_id directly, so pass it to the tool that does the work. Candidates are the user's recently-opened murals only. A mural they name but have not opened lately is found by search_murals`, which matches titles across every workspace they belong to.
set_outline_order
ChatGPTReorder the items already in the mural's presentation outline. This tool only reorders what is already there: it cannot put a widget into the outline. When the widgets are not in the outline yet — including a request that says which widgets should be the slides of a presentation, in what order — use add_to_outline instead, which appends them in the order given. This is the one and only tool for changing outline order — the whole outline is reordered in a single call, whether one item moved or all of them. widget_ids is the complete outline in its new order: every item currently in the outline, exactly once. The ids and their present order come from list_outline; the way to move an item is to echo that list back with the item in its new place. This tool only reorders. It cannot put a widget into the outline (add_to_outline) or take one out (remove_from_outline), so the set of items is the same before and after. Reordering the outline requires the current participant to be a facilitator. The tool resolves their role itself and rejects the request when they are not one. The response is a uniform envelope: status: "ok" (reordered — success: true, with a reordered count) or status: "error" (nothing reordered — success: false with an error_code; when the reorder call itself fails, every id is also listed in failed). Reordering is all-or-nothing: there is no partial result. Canvas Host loads the mural on demand.
troubleshoot
ChatGPTReturns step-by-step recovery guidance for failed Mural canvas tool calls, covering the common failure modes: unknown/stale tool names, Canvas Host synchronization and capacity errors, auth and access failures, view-only and archived refusals, no-mural-selected, concurrency limits, and screenshot and per-tool failures. Also covers a widget that comes back blank in a viewport screenshot. Errors surface as a raised tool error, as a success: false result dict with an error_code, or as an "Unknown tool" error this server raises while resolving the name. Convenience wrapper for get_skill("troubleshooting").
unlock_widgets
ChatGPTUnlock widgets on the canvas by id. This is the one and only unlocking tool — use it whether you unlock one widget or many; they are all unlocked in a single call. Works for both standard-locked and facilitator-locked widgets. Pass widget_ids as a list — always a list, even for a single widget (then it is a one-element list). A facilitator-locked widget can only be unlocked by a facilitator; the tool verifies this and rejects those widgets per item, while the rest of the batch still unlocks. Unlocking a group also unlocks its children, matching in-app behavior. Unlocking an area unlocks only the area itself, not its children. Unlocking a table unlocks the table and its table cells. The response is a uniform envelope: status: "ok" (all unlocked — success: true, with an unlocked count), status: "partial" (some unlocked, the rest in failed — success: false), or status: "error" (nothing unlocked — success: false with an error_code). Retry only the failed entries. Canvas Host loads the mural on demand.
update_mural_settings
ChatGPTUpdate settings for the current mural: Title, background color, canvas size, timer sound, and visitor avatar theme. Only provided parameters are changed. Changes persist through the Mural public API and stay synchronized with the active canvas context. Only facilitators may change settings; the tool verifies this and rejects the call if the current participant is not a facilitator.
update_tags
ChatGPTUpdate tag definitions' text, color, or icon. This is the one and only tag-update tool — use it whether you update one tag or many; they are all updated in a single call. Only the fields you pass on an item are changed; the rest of that tag's definition is preserved. Pass updates as a list — always a list, even for a single tag (then it is a one-element list). Each item is an object with a required tag_id plus at least one of: text — new label text. color_name — a curated MURAL tag color; one of: watermelon, peach, banana, mint, lime, blueberry, raspberry, grape, snowberry. icon_id — an icon id (from search_icons) to add or replace the tag's icon. remove_icon — pass true to clear the tag's icon (cannot be combined with icon_id). The response is a uniform envelope: status: "ok" (all updated — success: true, with an updated count and the per-tag results in tags), status: "partial" (some updated, the rest in failed — success: false), or status: "error" (nothing updated — success: false with an error_code). Retry only the failed entries. Canvas Host loads the mural on demand.
update_widgets
ChatGPTUpdate fields on existing widgets in place (area, arrow, shape, sticky note, table cell, textbox, title). Text fields hold the member's own content; classification, sentiment, or status is stored as a tag (what Mural calls a label) with add_tag, not in the text. updates is a list of {"widget_id", "values"}; values is a flat camelCase patch — only included fields change. Position: write x/y/width/height, not read-back position_x/position_y. With a parentId, x/y are parent-relative; outside the parent's bounds the widget silently detaches. Layering: stack: "front"|"back" (Bring to front / Send to back) fixes what covers what; never re-create. Failures: bad fields or ids fail per item into failed (status: "partial"); the rest apply. Retry only those; each error lists the allowed fields. Text: text is Markdown (bold, italic, lists, [label](url) links; headings render bold; no code, quotes or rules). On a sticky, setting text re-fits the font and overwrites a fontSize in the same patch — send fontSize in a second, text-free call to make it stick. When text changes on a textbox/title, height re-fits; width holds only when fixed-width (textbox default, title needs fixedWidth: true). shapeType takes the names create_shapes lists. Connectors: - text is the label, a plain string; null clears. - startRefId/endRefId re-anchor and recompute the endpoints. Don't send points/x/y/width/height in the same patch: they apply first and can distort a curve. null detaches an end in place. - The canvas may re-derive points; such ids return in adjusted (applied; don't retry). Orthogonal paths of 4+ points stay pinned only while every segment is axis-aligned; a diagonal bend reverts to auto-routing. strategy: {"type": "orthogonal", "fixed": false} keeps auto-routing. - arrowType: straight, curve, orthogonal, bezier. A switch is checked against the stored path; send fitting points in the same patch. Canvas Host loads the mural on demand.
add_tag
Claudeadd_template_to_canvas
Claudeadd_to_outline
Claudecreate_areas
Claudecreate_connectors
Claudecreate_icons
Claudecreate_mural
Claudecreate_shapes
Claudecreate_stickies
Claudecreate_table
Claudecreate_textboxes
Claudecreate_titles
Claudedelete_tags
Claudedelete_widgets
Claudeecho
Claudeget_canvas_overview
Claudeget_canvas_screenshot
Claudeget_document_tree
Claudeget_mural_access_info
Claudeget_mural_info
Claudeget_skill
Claudeget_viewport_screenshot
Claudeget_widget_by_id
Claudeget_widget_relations
Claudeget_widgets_screenshot
Claudeinvite_users_to_mural
Claudelist_outline
Claudelist_rooms
Claudelist_selected_widgets
Claudelist_skills
Claudelist_tags
Claudelist_widgets
Claudelist_widgets_in_viewport
Claudelist_widgets_near
Claudelist_workspaces
Claudelock_widgets
Claudemove_widgets_to_area
Clauderemove_from_outline
Clauderemove_tag
Clauderename_outline_item
Claudesearch_icons
Claudesearch_templates
Claudeselect_mural
Claudeset_outline_order
Claudetroubleshoot
Claudeunlock_widgets
Claudeupdate_mural_settings
Claudeupdate_tags
Claudeupdate_widgets
Claude
