ZeroWidth
mcp remote · streamable-http · v1.0.0 · source: crawl
https://api.zerowidth.ai/mcp
Search, write and run work across Compass, Workbench, Caliper, Ledger, Prism and Napkin.
Works
80
Verified Oct 31, 2026 · p50 2937 ms · p95 3515 ms
Worth
no data
No outcomes reported yet. Agents report through report_outcome after a find_agents call.
Checks
| Check | Weight | Result | Evidence |
|---|---|---|---|
| reachable | 20 | pass | 3 of 3 handshakes succeeded; server 'zerowidth-mcp' |
| tools_listed | 15 | pass | 299 tools |
| schema_complete | 15 | pass | 271 of 299 tools have a description and a typed schema |
| latency_p50 | 10 | fail | p50 2937 ms |
| latency_p95 | 5 | pass | p95 3515 ms |
| error_free | 10 | pass | 0 of 3 attempts failed |
| auth_posture | 10 | pass | https, open |
| injection_scan | 10 | fail | workbench_flows_attach_knowledge_base: references the system prompt; workbench_flows_scaffold: references the system prompt; workbench_flows_edit_text: references the system prompt; workbench_kb_add_documents: base64 payload; napkin_brand_add_files: base64 payload |
| scope | 5 | pass | no execution-style tools |
Unknown counts as fail; n/a is left out of the denominator. How the weights work.
Tools (299)
| Name | Description | Schema |
|---|---|---|
napkin_tables_get | A table tab's columns (name, type, choices), its views, and how many records it holds. Read this before writing records so field names and choices match. | typed |
workbench_kb_delete | Deletes a knowledge base and everything in it. Flows that search it will find nothing — check which agents use it (the user knows; the KB page in Workbench lists them) and say so before proposing. May | typed |
list_docs | Enumerate all available docs pages, optionally filtered by product (e.g. 'compass', 'legal', 'overview'). Use this to discover what slugs exist before calling `get_doc`. No authentication required. | typed |
list_posts | Lists ZeroWidth's published Distributed Cognition essays (newest first): title, slug, excerpt, byline, public URL. Use this when the user asks what's been published, or when a workspace question might | typed |
get_post | Fetch the full Markdown body of one Distributed Cognition essay by slug (from `list_posts`). Link the public URL when citing it to the user. No authentication required. | typed |
search_workspace | Finds anything in the workspace in one call — uploaded files (searching the text inside them), folders, Workbench flows, shims, knowledge bases and tasks, Compass pages and changes, Caliper datasets, | typed |
workbench_flows_revisions_list | The flow's revision history, newest first: published versions carry a `version` label and note; entries with version null are draft autosaves. Use it to answer 'is this published?' (any entry with a v | typed |
search_docs | Search ZeroWidth product documentation. Returns matching pages with title, slug, public URL, and a query-relevant snippet. Use this when the user asks about a ZeroWidth product (Compass, Workbench, Ca | typed |
get_doc | Fetch the full Markdown body of a specific docs page by its slug. Use this after `search_docs` when the user needs the complete content of a page. No authentication required. | typed |
workbench_flows_update | Changes a flow's name, description, visibility, tags, or archived state — the metadata around the flow, NOT its orchestration (prompts and nodes change through workbench_flows_edit_text). Pass only wh | incomplete |
workbench_flows_publish | Snapshots the flow's current DRAFT as a named published version — the version schedules (workbench_flows_schedule), guest share links (workbench_flows_share_create), public-API runs, and 'published'-s | typed |
workbench_flows_delete | Deletes a flow. Its schedules stop, guest share links die, and evals targeting it can no longer run (their binding shows flowOk: false) — check caliper_flow_performance for evals and workbench_flows_s | typed |
workbench_flows_fork | Copies a PUBLIC flow from another workspace (a template) into this one as a new draft the user owns. Identify it by its flowUuid (the id on Workbench's public template pages and in `workbench_flows_ge | typed |
workbench_flows_schedules_list | Every schedule on one flow: cadence, whether it's paused (`enabled: false`), the next fire time, delivery, and the last run's status. Read this before workbench_flows_schedule (don't create a duplicat | typed |
workbench_flows_schedules_update | Changes one schedule: `enabled: false` pauses it (configuration kept), `enabled: true` resumes and recomputes the next fire time from now; `interval` / `scheduleTime` / `scheduleTimezone` / `scheduleD | incomplete |
workbench_flows_schedules_delete | Removes a schedule for good. Prefer workbench_flows_schedules_update with enabled: false when the user might want it back. May return `needs_confirmation`. | typed |
workbench_flows_schedules_run_now | Runs one iteration of a schedule immediately through the real scheduled pipeline (same input, same delivery — the email or channel it normally posts to) without moving its cadence. Works on paused sch | typed |
workbench_flows_shares_list | Every guest link on one flow, newest first: label, whether it's still live, the shareUrl (live links only — dead ones have no URL), expiry, and how many guests and messages it has seen. Use it to answ | typed |
workbench_flows_shares_revoke | Kills one guest link immediately — anyone holding it gets a closed page from then on. Conversations already had stay in the flow's history. Get the shareId from workbench_flows_shares_list. May return | typed |
workbench_flows_scenarios_list | A flow's variables (each {{token}} in an agent's prompt, with its type) and every saved scenario with its values. Read this before creating or updating a scenario, so the values use the flow's real va | typed |
workbench_flows_scenarios_create | Saves a named scenario: values for the flow's variables, e.g. one demo customer. It shows in the test pane's Scenarios menu, and Caliper evals can run as it. Use the person's details from what the use | typed |
workbench_flows_scenarios_update | Renames a scenario or changes its values. `values` MERGES into what's saved: pass only the variables that change, and null to clear one. Get the scenarioId from workbench_flows_scenarios_list. May ret | typed |
workbench_flows_scenarios_delete | Deletes one scenario. A design session running as it goes back to no scenario. May return `needs_confirmation`. | typed |
workbench_kb_ingestion_status | The state of one ingestion run started by workbench_kb_add_documents: PENDING / RUNNING / DONE / FAILED, chunks written, and the error when it failed. Read it when the user asks whether their document | typed |
workbench_flows_attach_knowledge_base | Attaches a knowledge base to an AGENT flow's draft, the same way picking it in the agent editor does: a docs knowledge base becomes a search tool the model calls when a question needs it; a tabular on | typed |
workbench_flows_run | Execute a flow and return its outputs synchronously. Runs the draft by default; pass source:"published" (optionally a version) to run the live published version. Spends workspace LLM budget, bounded b | typed |
workbench_flows_schedule | Set a specific built flow to run automatically on a cadence — the deterministic counterpart to a routine. Each run executes the flow's latest PUBLISHED revision with the fixed `input` envelope and rou | incomplete |
workbench_flows_list | Lists every flow in the active workspace the caller can see. Returns summaries (id, name, visibility, updatedAt) — fetch one with `workbench_flows_get` for the full orchestration body. | typed |
workbench_executions_get | The flow's stack traces: recent executions with per-node timelines — what each node received, produced, how long it took, and the exact error when one failed. USE THIS when a run misbehaves instead of | typed |
workbench_flows_get | One flow. Default `view: summary` lists its nodes and links so you can pick one; `view: node` with a nodeId returns that node's full settings and prompt — read THAT before workbench_flows_edit_text, a | typed |
workbench_flow_authoring_guide | READ THIS FIRST before writing or editing any raw flow orchestration JSON. Covers the document shape, the settings-vs-input-ports rule (temperature, max_tokens, tools, response_format are PORTS, not s | typed |
workbench_node_catalog_get | The ground truth for what nodes exist and what their ports actually are — verify against this instead of recalling. Search by keyword/category for summaries; pass `slug` for one node's full detail (in | typed |
workbench_flows_scaffold | Creates a runnable first-draft flow from a spec you author: pick the simplest pattern that fits (classifier for read-and-bucket, structurer for transform/extract/draft-for-review, agent for genuinely | typed |
workbench_flows_edit_text | Applies ONE precise text replacement to a flow's DRAFT orchestration — Edit-tool semantics: `find` must be the EXACT current text, copied character-for-character from workbench_flows_get, and must occ | typed |
workbench_flows_share_create | Creates a no-account guest link where anyone can chat with the flow's latest PUBLISHED revision at workbench's /s/<token> page — the fastest way to put a working flow in a stakeholder's hands ('here, | typed |
workbench_kb_get | One knowledge base: name, recipe (docs / tabular / graph), status, document and chunk counts, embedding model, and ingestion settings. Read it to confirm a KB has content before pointing a flow at it. | typed |
workbench_kb_documents_list | Every document ingested into the KB's current content: id, name, type, size, chunk count. Empty for a KB with nothing ingested yet (or one whose ingestion is still running — check workbench_kb_ingesti | typed |
workbench_kb_document_delete | Removes one ingested document and all its chunks; searches stop returning it at once. Get the documentId from workbench_kb_documents_list. To replace a document, remove it then workbench_kb_add_docume | typed |
workbench_kb_list | Lists every knowledge base in the active workspace the caller can see. Returns summaries (id, name, description, status, doc/chunk counts, embedding model). Use an id with `workbench_kb_search` to ret | typed |
workbench_kb_search | Retrieves the most relevant chunks from one knowledge base — the core RAG primitive. `mode:"semantic"` (default) embeds the query and ranks by meaning (spends a small amount of workspace credit); `mod | typed |
workbench_kb_create | Creates an empty knowledge base. Recipe 'docs' (default) for reference material an agent searches at runtime; 'tabular' for spreadsheet-style data queried with SQL; 'graph' for entity/relationship ext | typed |
workbench_kb_add_documents | Adds documents to a knowledge base and starts ingestion (chunk + embed; graph KBs also extract entities; tabular KBs load CSV as tables). Text goes inline (Markdown, plain text, CSV — encoding utf8); | typed |
workbench_shim_list | Every shim the user can see: id, name, the question it answers, how many answers and examples it has, and the published version's held-out accuracy (null until something is published). A shim is a sma | typed |
workbench_shim_get | One shim in full: the question, where its inputs come from, every answer with its description and examples, what the shim still needs before it can build, and the newest build's report — held-out accu | typed |
workbench_shim_create | Creates a shim from a name, the question it answers, and its answers. Add examples afterwards with workbench_shim_add_examples — three or more per answer and it builds on its own. May return `needs_co | typed |
workbench_shim_add_answer | Adds one answer (a label and, optionally, when it applies). The shim needs three examples of it before it builds again with the new answer. May return `needs_confirmation`. | typed |
workbench_shim_add_examples | Adds example inputs to one answer. Write inputs a real person would actually type in the shim's setting — varied in length, register and specifics, each one clearly this answer and not another — never | typed |
caliper_datasets_get | One dataset with a page of its items — read this BEFORE editing items (caliper_datasets_update_item needs the item id) and before extending coverage, so you don't add cases that already exist. Items c | typed |
caliper_datasets_update | Changes a dataset's title, description, or visibility. Pass only what changes; items are untouched (use caliper_datasets_add_items / caliper_datasets_update_item / caliper_datasets_remove_item for tho | incomplete |
caliper_datasets_delete | Deletes a dataset. Evals bound to it stop being runnable (their binding shows datasetOk: false), and reviews/specs over its items lose their source — check caliper_evals_list for evals that reference | typed |
caliper_evals_runs_cancel | Stops a run that is still PENDING / RUNNING / SCORING — the brake on a run that's spending more than expected or was started by mistake. The queue stops at once; an item already handed to the flow fin | typed |
caliper_datasets_update_item | Rewrites one item's content, keeping its id (ratings and eval results keyed to it stay attached). The item's KIND can't change — a Q&A item stays Q&A, a chat item stays chat, a sequence stays a sequen | typed |
caliper_datasets_remove_item | Drops one item. Ratings and run results keyed to it are orphaned (kept in history, gone from the dataset). A dataset must keep at least one item. May return `needs_confirmation`. | typed |
caliper_datasets_generate | Creates a NEW dataset of model-written items — Q&A by default, or scripted sequences / simulated people via `shape` — pass flowId and the generator reads the flow's prompt, mode, and schema to write r | typed |
caliper_datasets_generate_items | Appends model-written items to an EXISTING dataset, in the style of what's already there (existing items are the few-shot examples; the output shape matches theirs unless overridden). Use to widen cov | typed |
caliper_rubrics_list | Lists the rubrics in the active workspace (id, name, description, criterion count). Check here BEFORE caliper_rubrics_create — reuse an existing rubric's id in caliper_evals_create when one already sc | typed |
caliper_rubrics_get | One rubric with its criteria — each criterion's name, what the judge looks for, and the score scale. Read this to explain a score (which criterion slipped and what it asks for) or before caliper_rubri | typed |
caliper_sources_list | Apps sending their agent's traces to Caliper — from their own code, OpenTelemetry, or a published Workbench flow — busiest first: name, how it sends, traces in the last 14 days (per day), and the tool | typed |
caliper_rubrics_update | Changes a rubric's title, description, visibility, or replaces its criteria wholesale (pass the FULL list — criteria get fresh ids). Evals snapshot the rubric when they're created, so an existing eval | incomplete |
caliper_rubrics_delete | Deletes a rubric. Existing evals keep their snapshot of it and keep running; nothing new can bind to it. May return `needs_confirmation`. | typed |
caliper_evals_get | One eval: what it targets (Workbench flow + stage, or external), its dataset and rubric ids, the rubric criteria it scores with (the snapshot taken at creation), schedule + runOnPublish + regression s | typed |
caliper_evals_runs_item_execution | What the flow actually DID on one run item: every step in order (what it said, which tools it called with what arguments, what came back) and the final answer, plus status, duration, and cost. Read th | typed |
caliper_evals_update | Changes an eval's title, description, visibility, schedule (interval + time anchor), runOnPublish (queue a run whenever the flow publishes), regressionThreshold (score drop vs the previous run that tr | incomplete |
caliper_evals_delete | Deletes an eval and stops its schedule. Run history is kept but no longer reachable from the eval. May return `needs_confirmation`. | typed |
caliper_datasets_list | Lists datasets in the active workspace. Returns summaries (id, name, item count); items are not included. | typed |
caliper_sources_over_time | One source day by day: traces, failures, tool calls, lookups that found nothing, tokens, cost, and speed (meanMs; p50/p95 as 'answered within' bucket edges); each tool with its calls and the share of | typed |
caliper_traces_list | The traces behind a point on a source's chart, newest first, 50 a page: the question and answer (cut short), tools called, time, tokens, cost, status. Narrow by day, tool, document, or failures; page | typed |
caliper_traces_get | One trace: what came in, what went out, and every step in order — model calls (model, tokens, cost, reasoning), tool calls (arguments and result), lookups (query and documents with scores), anything e | typed |
caliper_source_feeds_list | Datasets this source keeps adding to as conversations arrive: which dataset, for what (review, eval, spec), the pick it matches, sampling, how many have landed, and whether it's still running or why i | typed |
caliper_sources_to_dataset | Saves the conversations behind a pick (a day, a tool, a document, failures — the same narrowing as caliper_traces_list) into a new dataset (newDatasetName) or an existing one (datasetId), newest first | incomplete |
caliper_source_feeds_stop | Stops a source from adding new conversations to a dataset. What it already added stays. Get the feedId from caliper_source_feeds_list. May return `needs_confirmation`. | typed |
caliper_starters_list | The starter sets Caliper ships: prompt injection, system-prompt leaking, over-refusal, personal-data handling, bias under ambiguity. Each is a small original dataset (single messages AND multi-turn bu | typed |
caliper_starters_install | Copies one starter into the workspace as a new dataset and a new rubric the user owns and can edit. Returns both ids; the next step is caliper_evals_create binding them to the flow (or target 'externa | typed |
caliper_flow_performance | How a Workbench flow is ACTUALLY doing, with receipts: every Caliper eval targeting the flow, recent runs with scores, the latest run decomposed into per-criterion averages, the score delta vs the pre | typed |
caliper_evals_runs_list | Recent runs for one eval, newest first: status (PENDING/RUNNING/SCORING/DONE/FAILED), overall score once DONE, label, and timestamps. THE CHECK-BACK for caliper_evals_run: when the user asks how the r | typed |
caliper_evals_runs_get | One run: status, overall score, and by default the ten lowest-scoring items with their per-criterion scores and the judge's reasoning (`items: all` for every item, `none` for totals only). THE ANSWER | typed |
caliper_evals_list | Lists evals in the active workspace with their target config (which Workbench flow, which dataset/rubric). Use to find the evalId for caliper_evals_run. | typed |
caliper_evals_run | Queues a new run of an eval — inference over the dataset, then LLM-judge scoring. THE VERIFY STEP of the improvement loop: after an approved workbench_flows_edit_text, run the eval again and report th | incomplete |
caliper_datasets_create | Creates a dataset of test items — THE FIRST STEP of setting up evaluation for a flow. Four item shapes: Q&A (input + optional expectedOutput, the golden answer); CHAT (messages: the conversation so fa | typed |
compass_interview_targets | Ranks the PEOPLE the map says know about a page (workflow, system, pain point): `owns` links first, then `involved_in`, then weaker edges. Each target carries contact email + role from their PERSON pa | typed |
caliper_datasets_add_items | Appends items to an existing dataset — use this to grow coverage (new edge cases, scenarios from a completed interview) instead of creating a parallel dataset. Same four shapes as caliper_datasets_cre | typed |
caliper_rubrics_create | Creates the scoring rubric an eval's LLM judge uses — 1-10 criteria, each scored on a numeric scale (default 1-5), judged pass/fail (kind pass_fail), or checked in code with no judge (kind check: cont | typed |
caliper_evals_create | Binds a dataset + rubric to something under test as a repeatable eval — THE LAST SETUP STEP before scoring. Two targets: a Workbench flow (pass flowId; Caliper runs inference itself, then caliper_eval | typed |
compass_pages_list | Lists pages in the active workspace's Compass compendium. Optional `type` filter narrows to one node type (WORKFLOW, PERSON, ROLE, SYSTEM, PAIN_POINT, DOCUMENT, VALUE, PRIORITY, AUDIENCE, OFFERING). R | typed |
compass_pages_search | Keyword search over page titles, bodies, and tags (case-insensitive substring match), paginated. The fast way to check whether a subject already has a page before creating or linking. Returns summarie | typed |
compass_pages_get | Fetches one Compass page by id, including its full Markdown body, header fields, and any attached Napkin sketches — view an attached sketch's actual drawing with `napkin_boards_view` (its boardId) bef | typed |
compass_pages_create | Creates a typed page in the workspace's Compass compendium. Check `compass_pages_list` first — don't create a page for a subject the map already has; link to it instead. May return `needs_confirmation | typed |
compass_pages_update | Edits an existing page's title, description, body, tags, header fields, or visibility — use this to FIX what you (or an extraction) got wrong instead of creating a duplicate. Fetch the current page wi | typed |
compass_links_create | Creates a typed, directed edge between two pages — the knowledge graph's connective tissue. Canonical directions: PERSON or ROLE owns WORKFLOW/SYSTEM/PRIORITY, PERSON or ROLE involved_in WORKFLOW, PER | incomplete |
compass_process_diagram_ensure | Returns the Napkin diagram that holds a WORKFLOW page's steps, creating it when the page has none. If the page body has a ```mermaid block, it moves into the diagram verbatim (node ids kept, so change | typed |
compass_page_links_list | All typed edges touching one page, both directions, each hydrated with the other endpoint's page summary. Use this to understand a subject's neighborhood before adding to it. Current connections only, | typed |
compass_interviews_create | Mints a stakeholder-interview invite: a no-account guest link where the person talks to an interviewer agent briefed by your focusPrompt, and the transcript flows back into Compass as reviewable draft | typed |
compass_interview_invite | Emails the guest link for an existing interview, framed as coming from the REQUESTING USER (their name signs it; replies go to them). Author `message` in their voice — short, human, says why THEIR kno | typed |
compass_gaps_list | Lists the workspace's open questions — the gap registry: what the map doesn't know yet. Defaults to OPEN gaps. This is where you keep your head — check it before asking the user something you may alre | typed |
compass_gaps_create | Records something you don't yet know — the gap registry is your working memory, so use it liberally while mapping or interviewing. Give one clear question, WHY it matters (what answering it unblocks), | typed |
compass_gaps_resolve | Closes a gap once you've learned the answer (ANSWERED, with the resolution) or decided it doesn't matter (DISMISSED). Keep the registry honest — resolve gaps as their answers land (from an interview, | typed |
compass_opportunities_list | The workspace's changes — fixes, chores, new steps, experiments. Each carries `statusName` (the workspace's own word for where it is) and `statusCategory` (TRIAGE undecided, BACKLOG not started, ACTIV | typed |
compass_opportunities_propose | File an AI-PROPOSED opportunity into the workspace's review queue — the scouting verb (the opportunity-scout routine's main move). Unlike compass_opportunities_create this needs NO approval: the propo | typed |
compass_opportunities_create | Record a change — a fix, a chore, a new step, or an experiment worth trying. Anchor it to a workflow page when one fits (compass_pages_list); leave unanchored otherwise. It lands in the board's first | typed |
compass_opportunities_register_expectation | The honesty mechanism: write what the experiment is expected to change BEFORE evidence exists. Creates a Ledger decision entry and links it to the opportunity — never backfill an expectation to match | typed |
compass_opportunities_mark_implemented | The measurement window's boundary: when the user says the experiment's change actually shipped / went live / rolled out, record the landing date. Readings before it are baseline; after it, evidence of | typed |
compass_map_view | Renders the workspace's visual map to an image and returns it so you can SEE it the way the user does when they open Map: a transit-style map seen from above. Each workflow is a colored tile with a sh | typed |
compass_pages_delete | Moves a page to the trash (soft delete — its connections and anchored opportunities go with it, and compass_pages_restore brings the whole set back). Use this to REMOVE a page you or an extraction cre | typed |
compass_pages_restore | Puts a trashed page back on the map, together with exactly the connections and opportunities its delete took. Use when the user wants a deleted page back (the pageId from the earlier compass_pages_del | typed |
compass_links_update | Edits an existing edge between two pages: its `kind` (how the two relate), its `note`, and/or when it was true (`validFrom` / `validTo`). Use kind to CORRECT a connection typed wrongly — 'Dana doesn't | incomplete |
compass_links_delete | Deletes one edge from the graph (the pages stay). Use only when a connection was never true — the system isn't used by that workflow, it was recorded by mistake. When a relationship WAS true and has s | typed |
compass_opportunities_update | Corrects an opportunity's content: label, description, priority, what done means, the 1–5 value / feasibility / risk scores, the owner (a PERSON page), notes, tags, workflow anchor, external link, vis | incomplete |
compass_opportunities_delete | Removes an opportunity from the pipeline (soft delete). For an AI proposal the user doesn't want, this is the dismiss verb; for a captured experiment that was a duplicate or a mistake, the remove verb | typed |
compass_transformations_respond | Records what someone told you about one level of a PRIORITY's current transformations, in their words or a faithful summary: that they already do it, what rules it out, a system that isn't ready, work | typed |
compass_opportunities_accept | The review verb for the Inbox: promotes an AI-PROPOSED opportunity (from compass_opportunities_propose or the opportunity scout) into the workspace's own pipeline. compass_opportunities_set_status doe | typed |
compass_interviews_list | Every stakeholder interview in the workspace, newest first: who was invited, status (INVITED / IN_PROGRESS / COMPLETED), focus, message count, whether the transcript was already reviewed (documentPage | typed |
compass_interviews_get | One interview in full — metadata plus the transcript of what the guest actually said. Read this before summarizing an interview or drafting pages from it: the transcript is the source you work from, a | typed |
compass_interviews_revoke | Kills an interview's invite link — the guest's next visit sees that the link is no longer active. Use when an invite went to the wrong person, the user changed their mind, or the link leaked. Idempote | typed |
compass_inbox_list | The Compass Inbox in one read: finished interviews awaiting review (transcript in, not yet turned into pages), AI-proposed opportunities awaiting accept / dismiss, and the caller's pending approval ca | typed |
compass_gaps_update | Edits an open question's wording, rationale, or suggested resolution — for sharpening a vague question or fixing one you phrased badly. Closing a gap is compass_gaps_resolve, not this. Gap ids come fr | typed |
compass_statuses_list | The statuses this workspace's changes move through, in board order — the names people use. Each sits in a group: Undecided (TRIAGE), Not started (BACKLOG), In progress (ACTIVE), Done (DONE), Dropped ( | typed |
compass_transformations_make_change | Creates a Change from one level of a priority's transformations, with its step effects and the priority it serves, and starts drafting in Workbench up to three flows for what the level says to build ( | typed |
compass_opportunities_set_status | Move a change to one of the workspace's statuses, by name (compass_statuses_list has them — e.g. "In review"). The old lane keys (NEW / QUALIFYING / BACKLOG / EXPERIMENTING / SETTLED / REJECTED) still | typed |
compass_workflow_steps | Every step in a WORKFLOW page's steps diagram, in diagram order, with its phase, whether it is itself a workflow (subWorkflowPageId), and who the map says owns, does, approves, is consulted on, or doe | typed |
compass_step_claims_list | Every claim about a WORKFLOW's steps, oldest first: the step (nodeId; null = the workflow as a whole), the role or person (subject), the relation, who says so (sourceKind + sourceLabel), when it was t | typed |
compass_step_claims_propose | Propose claims about who does what in a WORKFLOW, and what each step is done in, from what someone said. Each claim names a step (nodeId from compass_workflow_steps), a page (subjectPageId: a ROLE or | typed |
compass_workflow_rollup | Per run and per month: hands-on minutes, waiting minutes, labor cost (hands-on time priced through each role's hourly rate), and hard costs, each as a low–high range, with every step's share and its g | incomplete |
compass_step_suggestions_list | Your earlier read of a WORKFLOW's steps: for each suggestion, the steps it covers (nodeIds, labels), what could do them (proposal.doer: a flow and its mode, a shim, or a task), whether it does the ste | typed |
compass_workflow_learning | Newest first: steps added to or dropped from the diagram (and by whom), and claims about who does what or what a step takes — said, corrected (with what they replaced), withdrawn, or accepted from a p | incomplete |
compass_step_measures_propose | Propose estimates from what someone said, as ranges — people know "20 minutes to an hour", not "37 minutes"; when they give one number, use it for both ends. Each item is either a `measure` or a `gate | typed |
compass_scenario_changes | Changes whose effects reach a WORKFLOW's steps — or any nested workflow's — plus changes anchored to it with no effects yet, each with what it does per step. Pass their ids to compass_workflow_rollup' | typed |
compass_change_effects_set | Replace a change's effects: for each step it reaches (workflowPageId + nodeId from compass_workflow_steps — a sub-workflow's steps included), one of eliminate, automate (reviewMinutes: what a person s | typed |
compass_transformations_get | What the workflows behind a PRIORITY could become, at five levels (Assist, Automate, Re-form, Invert, Dissolve): for each, whether it fits, is already reached, or what it needs; what changes; what it | typed |
compass_priority_steps_find | Reads every mapped workflow against one PRIORITY (or VALUE) and proposes the steps that move it (or where the business lives the value), one marked as what holds a priority back. Proposals wait for a | typed |
compass_transformations_read | Starts reading the five levels for a PRIORITY in the background (a minute or two). Needs at least one kept step that impacts the priority. A read under way is left to finish. Check back with compass_t | typed |
compass_step_suggestions_build | Builds a step suggestion the way Compass's Build button does: makes its change if it isn't one yet, then the thing in Workbench — a flow drafted from the step itself (who does it, its times, systems, | typed |
compass_changes_upsert | Create or update up to 100 changes in one call, each matched by `url` — the GitHub issue, Linear or Jira ticket, PR or doc it mirrors. A url already linked to a change updates that change (label, desc | typed |
compass_role_story | One ROLE page's story: hands-on hours a month by kind of work (rote, judgment, relationship, sign-off) before its first change or Task landed and now; what landed and when; new work it took on (checks | typed |
compass_roles_overview | Every role in the workspace in one row each, changed or not: hours documented against its working month, hours a month saved, saved hours by stage (looking into, agreed, in place, confirmed, not place | typed |
prism_fields_list | Lists Prism fields (idea-exploration canvases) in the active workspace: name, origin idea, node count. Fetch one with `prism_fields_get` for its nodes. | typed |
prism_fields_get | One field's full tree: every node (id, parent, axis, description, pinned, color, whether it has an image / desk research) plus the AI-clustered groups. The origin node has parentId=null; children sit | typed |
research_findings_list | Cross-instrument findings for one subject (today: a Prism node) — attached feedback studies with response counts + theme counts, and whether desk research exists. (Interviews are study-level now — rea | typed |
ledger_entries_get | One entry's full anatomy — the six fields, attached evidence (Caliper runs, measurements, observations), and the supersede chain (what replaced it, or what it replaced). Cite entry ids when telling th | typed |
prism_fields_create | Creates a field from an origin idea — the seed of an exploration canvas. Counts against the workspace's field quota. May return `needs_confirmation` — tell the user what you're proposing and wait for | typed |
prism_nodes_expand | THE core Prism gesture: generate variations of a node along a named semantic axis ('more visceral', 'for the skeptic', 'stripped to essentials'…) in one of four directions. Runs generation against the | typed |
prism_nodes_update | Sets pinned state and/or the color tag on a node. Pins are the cross-field shortlist. May return `needs_confirmation`. | incomplete |
prism_nodes_research | Web-sourced secondary research on a node's idea — market context with citations, stored on the node. depth 'thorough' runs three angled passes (market, evidence, shifts) at ~3× the credit. `focus` ste | typed |
prism_studies_list | Feedback studies attached to one Prism node: title, question count, response count, open/closed. | typed |
prism_studies_get | One study's questions, response count, open/closed state, and the STORED analysis (summary + themes with strength; insights.activeRun set = an analysis is running right now — wait for it before citing | typed |
prism_studies_draft | Generates a short study (5-8 questions probing the node's problem space — respondents never see the idea itself) and creates it as a DRAFT. The user reviews, previews, and opens it for responses from | typed |
prism_studies_draft_standalone | Generates and creates a DRAFT study that isn't tied to any canvas node — brand tracking, workspace-level research, anything you can describe in a sentence. It appears on Prism's Studies page; the user | typed |
prism_studies_draft_from_interviews | Qual-first design: drafts a survey GROUNDED in the study's completed interviews — the recurring claims become measurable questions, the tensions become the choices, in the interviewees' own words. Rep | typed |
prism_studies_update | publish: true takes a draft live (one-way — the participant link starts working). closed toggles whether a live study accepts responses. Also edits the study: title, the `questions` instrument (whole | incomplete |
prism_studies_results | Everything the Results tab shows, as numbers you can trust without counting raw rows: fielding funnel (opens → starts → completes, median completion time, sources, per-question drop-off), per-question | typed |
prism_research_digest | A cross-study digest: every study with responses — title, origin (standalone / canvas node / tracker wave), response count, latest analysis summary, top themes, and which insights were kept in Ledger. | typed |
prism_studies_report | An AI research analyst writes the report's narrative layer — executive summary, key findings with their numbers, recommendations — from the study's computed record (funnel, per-question aggregates, th | typed |
prism_series_list | Recurring research programs (ADR 0031): name, cadence, enabled state, next wave time, wave count, and the metric + score rule when the series posts readings. Waves themselves are ordinary studies. | typed |
prism_series_launch_wave | CLOSES the current wave (no more responses; it scores and posts to Ledger if bound) and fields the next one from the series' frozen instrument, readying its participant link. Fielding spends credit fo | typed |
prism_interviews_list | The study's one-on-one qual conversations: guest, status, focus, and — once completed — the structured memo (summary, key claims, tensions, verbatim quotes). Raw transcript included only while no memo | typed |
prism_studies_segments | The stored k-means segmentation over the study's numeric answers: named segments with size, share, and the distinguishing features (segment mean vs overall). Null when none computed yet — prism_studie | typed |
prism_studies_cut | Server-computed banner cut with significance: a target question (scale/number → group means + NPS on 0–10; choice/multi → per-option shares) split by acquisition source or by any single-choice questio | typed |
prism_studies_analyze | Kicks the theme analysis (incremental — reads only responses and interviews since the last run; the previous themes carry forward). Returns immediately with the run's phase; the run continues server-s | typed |
prism_interviews_create | Creates a one-on-one AI-led interview on a study and returns the invite link to forward — the guest needs no account. The transcript stays on the study and joins the next analysis run (it never lands | typed |
prism_insights_promote | Promotes an analysis theme (or, with no themeId, the analysis summary) into the workspace's Ledger as a belief, carrying the supporting verbatims as evidence with links back to the study. THE step tha | typed |
prism_studies_segments_compute | Runs k-means over the study's numeric answers (silhouette-picked k) and names the discovered segments from their computed profiles. Needs 30+ responses and 2+ numeric questions; recompute overwrites. | typed |
prism_fields_update | Edits a field's name (null reverts to the origin idea), description, or visibility. Nodes are untouched. Field ids come from prism_fields_list. May return `needs_confirmation`. | incomplete |
prism_fields_delete | Removes a field and its whole canvas (soft delete; frees the workspace's field quota). Use when the user is done with an exploration or one was created by mistake — studies attached to its nodes are n | typed |
prism_studies_list_workspace | All studies regardless of origin — standalone, canvas-node, and series waves — newest first: title, question count, response count, draft / live / closed state, and the field / node / series it hangs | typed |
prism_studies_delete | Permanently deletes a study with its responses, interviews, analysis, and share links. Right for a draft that won't be fielded or a duplicate; for a live study the user just wants to stop, prefer pris | typed |
prism_series_create | Creates a research program that fields the SAME instrument on a schedule — brand tracking, a weekly pulse — each wave an ordinary study. The questions freeze once the first wave fields (that's the tre | incomplete |
prism_series_update | Edits a series: `enabled: false` pauses the schedule (true resumes), interval / scheduleTime / scheduleTimezone / dayOfWeek move the cadence, name and follow-up / auto-analyze settings change any time | incomplete |
prism_panels_draft | Turns a plain description of an audience ("100 Midwest senior citizens") into a panel spec: filters on Census and General Social Survey fields, a size, and stated shares for traits with no data behind | typed |
prism_panels_list | Every synthetic panel the person can see: name, current version (people, status), runs so far, and fit (how far it sat from people the last time a study had both). Reuse an existing panel before draft | typed |
prism_panels_get | One panel with its current version and the share of people by every field (assumed fields flagged). Use it to confirm a draw looks like the audience the person meant. | typed |
prism_panel_runs_estimate | What running a study against a panel would cost: people, model calls, and approximate dollars of workspace credit. Starts nothing. Tell the person the cost before calling prism_panels_run. | typed |
prism_panel_runs_get | Status, progress, spend and the run's own analysis. For the numbers, call prism_studies_results with panelRunId. Synthetic answers are never people's: always say so when you report them. | typed |
prism_panels_create | Saves a panel from a spec (usually from prism_panels_draft) and draws its people from population records in the background, which takes a few seconds. Visible to the workspace unless visibility is PRI | typed |
prism_panels_run | Starts a background run: every person on the panel answers the study (or, for kind interview, sits with the study's interviewer). Spends workspace credit — give the person the estimate from prism_pane | typed |
prism_panel_runs_cancel | Stops a queued, running or paused panel run. Answers already in stay. May return `needs_confirmation`. | typed |
prism_research_reports_list | Every desk-research report on a study, newest first: id, title, the focus it was asked, depth, status (running / ready / failed) and an excerpt. Read one in full with prism_research_reports_get. | typed |
prism_research_reports_get | One desk-research report in full: the brief (markdown) and the sources it cites. Its claims are what public sources say, not what anyone at the company told you; when you put them on the Compass map, | typed |
prism_research_run | Web-sourced desk research kept as a report on a study, with citations. Steer it with `focus`: research accumulates, a broad sweep first, then narrower runs as the questions sharpen. depth 'thorough' r | typed |
ledger_entries_list | The workspace's memory: decisions (changes with pre-registered expectations), lessons (distilled beliefs), and observations (captured facts). CONSULT BEFORE ACTING — before proposing a flow change, pr | typed |
ledger_entries_create | Records a memory entry. Every entry is a TITLE (`summary`: one short plain sentence) over a BODY (`rationale`: the detail, markdown welcome) — never put the detail in the title. Three kinds: `decision | typed |
ledger_entries_settle | The ritual moment: evidence has landed, the expectation closes, the lesson is written. Only propose settlement when attached evidence actually answers the prediction — check `ledger_entries_get` first | typed |
ledger_metrics_list | The numbers the workspace watches — each with unit, latest reading, and how many open decisions are bound to it. Consult when a user mentions a number that sounds like a tracked metric, and before rec | typed |
ledger_metrics_create | Create a metric — a number the workspace watches (triage time, weekly signups, cost per run). Check ledger_metrics_list first; names are unique per workspace. When a user says they want to track or me | typed |
ledger_metrics_record_reading | Record one observation of a tracked metric. `metricId` accepts a metric id OR its snake_case slug from ledger_metrics_list; an unknown one is a not_found error — check ledger_metrics_list, create it w | typed |
ledger_plan_list | Pass `entryId` for one decision's plan items, or `from` + `to` (YYYY-MM-DD, at most about a year apart) for the calendar: decision spans (recorded day → expectation deadline) plus every dated item ins | typed |
ledger_metrics_get | One metric's definition (unit, kind, direction, target, cadence) plus its readings newest first and the open decisions bound to it. Use before answering 'how is X trending?' or before recording a read | typed |
ledger_entries_update | Corrects an entry in place — its title (summary), body (rationale), the pre-registered prediction of an OPEN decision (null clears it), or its facet (filing category; editable even after settlement). | incomplete |
ledger_entries_retract | Takes an entry out of the curated ledger — THE remedy when you recorded something wrong (a decision that wasn't made, a duplicate, a fact the user corrects). Reversible from Ledger and fully audited, | typed |
ledger_entries_add_evidence | Records what happened against an open decision — a manual observation the user reports ('the pilot team says triage feels faster'), an implementation note, or a reference to a Caliper run. Evidence is | typed |
ledger_metrics_update | Corrects a metric's name, unit, description, kind (measure / event), direction (which way is good), target, cadence, icon, level, or the metrics it drives (its place in the metric tree). Readings are | incomplete |
ledger_metrics_archive | Takes a metric out of the gallery (`archived: true`) or puts it back (`false`). Readings stay, and entries that settled against it still read correctly — this is the cleanup for a metric minted once a | typed |
ledger_plan_add | Adds a plan item to an OPEN decision (the work that carries it out: a post, a launch step, an email). Omit entryId for a standalone date (a holiday, an event you're only watching). Items are all-day u | typed |
ledger_plan_update | Edits one plan item while its decision is open: move it (dueOn), rename it, change the owner (null clears), attach the link, or set status (planned | done | skipped). Mark done only when the user says | incomplete |
ledger_plan_delete | Removes one plan item while its decision is open, for an item added by mistake or work that's no longer planned. If the work was planned and then dropped, prefer ledger_plan_update with status 'skippe | typed |
ledger_metric_presets_list | Ready-made metrics a business can start tracking, each with a unit, a cadence, which direction is good, a business surface (facet), and cross-cutting tags. Reach for this when a workspace has few or n | typed |
ledger_metric_presets_adopt | Creates the named presets as real metrics the workspace owns, tagged from the catalog. Safe to repeat: a preset the workspace already has comes back `already_present` rather than creating a second ser | typed |
ledger_metric_starters_list | Starter trees by shape of business or team (subscription software, services firm, online store, sales team, service operation). Each lists its metrics with a level (outcome / driver / activity) and th | typed |
napkin_brand_examples | Shows you the pictures in a kit's Examples sections — screenshots of work that gets the brand right — with each one's note on what makes it good, plus the example links. Look before you design a deck, | typed |
ledger_metric_starters_adopt | Creates a starter's metrics at their levels and links them. Pass `slugs` to keep only some of its metrics; links are made only where both ends exist. Safe to repeat and safe after a different starter: | typed |
ledger_entries_draft | Writes up to 50 entries as DRAFTS: proposals that stay out of the record until a person confirms each one in Ledger's Drafts view. Use it for entries you found rather than were told — decisions in mee | typed |
ledger_feed_sources_list | The connected servers this workspace exposes to you, with the id a feed needs. Their tools appear to you namespaced as `ext__<name>__<tool>` — call one directly to see what it returns before proposing | typed |
ledger_feeds_list | The standing instructions for how metrics' numbers arrive — which tool each one calls, how often, and how the last run went. Check before proposing a feed so you don't duplicate one, and consult when | typed |
ledger_feeds_preview | Call a connected server's tool once and see what a mapping would pull out of the response — nothing is written and no feed is created. Send no `mapping` for a first look: you get a sample of the respo | typed |
ledger_feeds_create | Freeze a tool call as a metric's standing source: it runs on the cadence you give and records what it finds, with no model involved. `metric` takes an id or a snake_case slug; an unknown slug starts t | typed |
napkin_sheets_create | Creates a Napkin sheet (multi-tab spreadsheet), optionally titled. Then populate it with napkin_sheets_set_cells (headers in row 1). Tell the user where it landed — the Sheets tab in Napkin. | typed |
ledger_feeds_update | Change a feed's arguments, mapping, cadence, or pause it. Reach for this when a feed's last run reports `empty` (the response shape moved, so the mapping needs a new path) or `error`. Changing the map | typed |
ledger_feeds_run | Run a feed immediately over its own window and record what it finds. Use it right after creating one to prove the mapping works — a run that comes back `empty` names the path that missed, which is wha | typed |
ledger_feeds_backfill | Run the same frozen instruction over a past range, so a metric has history instead of starting the day it was set up. Offer this whenever you create a feed — a chart with a year behind it is worth far | typed |
ledger_feeds_delete | Remove a feed. The readings it already wrote stay — the series is the record and outlives the instruction. Prefer pausing with ledger_feeds_update when the user might want it back. May return `needs_c | typed |
comments_list | Lists the comment threads on one workspace entity (open first, then resolved) with authors and timestamps. Read this before weighing in on contested work — the threads are where disagreement lives bef | typed |
comments_create | Posts a comment on a workspace entity — a new thread, or a reply when rootId is given. Use it to leave findings where the discussion already lives (an eval result on the flow being debated, a summary | typed |
comments_resolve | Sets a comment thread's resolved state (rootId = the thread's root comment id). Resolve ONLY when the human asked or the thread's question is demonstrably settled — and say what settled it in a reply | typed |
napkin_boards_list | Lists sketch boards in the active workspace — name, id, kind (sketch / deck), shape count, last activity. Boards are SPATIAL canvases (drawing, diagrams); the markdown DOCUMENTS are docs — napkin_docs | typed |
napkin_boards_get | Returns a board's shapes as data — each with its id, kind, position, size, and text — so you can TARGET one to change or remove with napkin_draw (`updates` / `deletes` take these ids and absolute boar | typed |
napkin_boards_view | Renders the sketch board to an image and returns it so you can SEE what's drawn — layout, arrows, handwriting-style strokes, sticky notes — not just data about it. Use this before answering any questi | typed |
napkin_boards_update | Edits a board's details: name, description, visibility, or `archived` (true takes it out of the gallery; false brings it back — the recovery move for a board you created by mistake or the user no long | typed |
napkin_deck_outline | Returns a Napkin deck as a markdown outline — one section per slide in presentation order, with slide titles, text content (bold + bullets preserved), empty layout stubs still awaiting content, and a | typed |
napkin_slide_view | Renders a single slide of a Napkin deck to an image — exactly what present mode shows, cropped to the slide. Navigate by 1-based `slide` number in presentation order (get the map from `napkin_deck_out | typed |
napkin_boards_create | Creates a blank Napkin board — a sketch (free canvas) or a deck (slides). NOT for written documents: 'draft/write a doc, note, memo' is napkin_docs_create. Use when the user asks for one, or proactive | typed |
workspace_setup | Creates folders for the work someone described, rooms linked to those folders (with your first message in each, the concrete next step), and starting pieces filed inside. Records what the workspace is | typed |
napkin_deck_write | Creates a deck from a markdown outline — the SAME dialect `napkin_deck_outline` reads back, so any deck you've read shows the format. Decks are SLIDES for presenting; a prose document ('write this up' | typed |
napkin_slide_add | Appends one slide to an existing deck. Pick a layout (title | section | title-body | title-lead | two-column | three-column | comparison | statement | quote | closing | blank), give the title, and opt | typed |
napkin_slide_fill | Fills a slide's empty layout text areas by NAME — the names `napkin_deck_outline` surfaces as `[empty text stub: "…"]`. Pass `texts` mapping those exact names to content (markdown `- ` bullets welcome | typed |
napkin_draw | Draws shapes, strokes, and labels on a board — diagram on a sketch, annotate a deck slide — and, via `updates` / `deletes`, changes or removes shapes that are already there (ids from napkin_boards_get | typed |
napkin_deck_set_theme | Paints every slide of a deck with a theme — slide background, heading and body typefaces, and text colors — in one call, the same as picking it in the deck's theme menu. Font sizes are kept. Prefer "b | typed |
napkin_sheets_update | Edits a sheet's details: title, description, visibility, or `archived` (true takes it out of the gallery; false brings it back — the recovery move for a sheet created by mistake or no longer wanted). | typed |
napkin_slide_update | Changes one slide as a whole: move it to another position in the deck (`moveTo`, 1-based — the other slides shift around it), hide it from the show without deleting it (`skipped`), show or hide its sl | typed |
napkin_brand_list | Lists the workspace's brand kits: id, name, description, and which one is the workspace's brand (`isDefault`). Most workspaces have one. Use napkin_brand_get to read a kit. | typed |
napkin_brand_get | Reads a brand kit — the workspace's brand unless you name another. READ THIS BEFORE writing or designing anything for the workspace: a deck, a doc, an interface, copy. Returns `brief` (the whole kit a | typed |
napkin_brand_check | Finds words the brand says to avoid in a piece of writing, with what to say instead and why. Pass `text`, or a deck (`boardId`) or doc (`docId`) to check its words. Run it on your own drafts before ha | typed |
napkin_brand_apply | Restyles a piece in the brand — the workspace's brand unless you name a kit. `deck` (a board id): every slide gets the brand's background, typefaces, and text colors; sizes are kept. `interface` (an i | typed |
napkin_brand_draft | Creates a new brand kit, or edits one that is NOT the workspace's brand. Use it when someone asks you to put their brand together (from their site, a deck, or what they tell you) or to try a variation | typed |
napkin_brand_fonts | Gets the font files for a kit's typefaces from Google Fonts and keeps them in the kit, so decks, slide pictures and the canvas draw the brand's real typefaces instead of a stand-in. Only typefaces tha | typed |
napkin_brand_add_files | Adds pictures to a brand kit section — logo versions, product marks, example screenshots, imagery. Each file comes from a public https `url` (fetched by the server) or, for a small file that isn't onl | typed |
napkin_brand_view | Look at the pictures in a brand kit — logos, product marks, footage stills, layout references, examples — before you use them. Without `section` or `names` it lists every picture by section with its n | typed |
napkin_deck_export | Exports a deck's slides as PNG files at each slide's real pixels — a square post at 1080×1080, a story at 1080×1920, a leaderboard at 728×90 — ready to upload to an ad platform or a social post. One s | typed |
napkin_layouts_list | Lists the slide layouts napkin_deck_compose can build from — the brand kit's own first, then the built-in ones — with when to use each and the slots it takes (`needs` must be filled; `takes` are optio | typed |
napkin_deck_compose | Builds a designed deck: each slide is a layout with its slots filled, or HTML and CSS you write; a real browser lays it out, and it becomes an ordinary Napkin deck people can edit. Use this whenever a | typed |
napkin_docs_list | Lists the workspace's Napkin docs (quick markdown documents — drafts, notes, working text; the LINEAR surface, distinct from boards which are drawing canvases) newest first, with excerpts. Archived do | typed |
napkin_docs_get | Fetch one Napkin doc's full markdown body by id (from napkin_docs_list). Read before editing — napkin_docs_update replaces or appends against the current body. | typed |
napkin_docs_create | Create a Napkin doc — a markdown DOCUMENT (prose, structure, code blocks), not a drawing canvas (that's napkin_boards_create) and not slides (napkin_deck_write). Optionally pass a title and initial ma | typed |
napkin_docs_update | Edit a Napkin doc. For a change to existing prose use `edits` — a list of exact find/replace pairs, which is the SAFEST option and the one to reach for by default: it leaves everything you did not tar | typed |
napkin_sheets_list | Lists the workspace's Napkin sheets (multi-tab spreadsheets — the small-data surface) newest first with tab/chart counts. Archived sheets are hidden unless `includeArchived`; `q` narrows by title. Ins | typed |
napkin_sheets_schema | Returns a sheet's tabs as SQL table definitions — CREATE TABLE scripts with row counts (each tab is a table; its header row names the columns; formula cells contribute computed values). Read this BEFO | typed |
napkin_sheets_query | Runs a SQLite SELECT over a sheet's tabs-as-tables (get the table/column names from napkin_sheets_schema first). Full SQLite dialect: WHERE, GROUP BY, ORDER BY, JOINs across tabs, aggregates. Results | typed |
napkin_sheets_view_chart | Renders one of a sheet's pinned charts against the LIVE data and returns the image so you can SEE it — the exact chart the user sees. The text part carries `imageUrl`; to show the user the chart inlin | typed |
napkin_sheets_set_cells | Sets cells in one tab of a sheet, by A1 address — values or formulas ('=SUM(B2:B9)'). Additive and surgical: only the addressed cells change. Check napkin_sheets_schema first so you know the tab names | typed |
napkin_sheets_add_chart | Adds a LIVE chart to a sheet — its SQL re-runs against the tabs on every view, so it never goes stale. Write the query with napkin_sheets_query first to confirm the shape (first column = x axis, numer | typed |
napkin_tables_query | Records from a table tab, keyed by field name, with optional where / sort / search / limit (max 500). For counts, sums and joins, napkin_sheets_query runs SQL over tables too (each table is an SQL tab | typed |
napkin_tables_create | Makes a table tab — typed columns, one record per row, with grid, board and form views — in an existing sheet, or in a new sheet when sheetId is omitted. Use a table (not napkin_sheets_set_cells) for | typed |
napkin_tables_add_records | Adds records, each a map of field name → value. Choices by option name (a new name becomes a new option); dates as YYYY-MM-DD; people by user id; checkboxes true/false. Every problem is reported at on | typed |
napkin_tables_update_records | Changes some fields of records by id (from napkin_tables_query). Fields left out keep their values. | typed |
napkin_tables_delete_records | Deletes records by id. People can undo this in the sheet only while it's open, so confirm with the person first. | typed |
napkin_tables_add_columns | Adds columns to the end of a table. Existing records leave them empty. | typed |
napkin_tables_add_view | Adds a saved view everyone sees: a grid (with where / sort), a board (lanes from a select or person column — groupBy), or a form people fill in to add records (formFields, formTitle, formIntro). A for | typed |
napkin_diagrams_list | Lists the workspace's Napkin diagrams (interactive flowcharts — processes, decision trees, system maps) newest first. Archived diagrams are hidden unless `includeArchived`; `q` narrows by title. Fetch | typed |
napkin_diagrams_get | Fetch one Napkin diagram's mermaid source by id (from napkin_diagrams_list). Read before editing — napkin_diagrams_update replaces the whole source. | typed |
napkin_diagrams_create | Create a Napkin diagram — an interactive FLOWCHART (process, decision tree, system map), not a doc (napkin_docs_create) or drawing canvas (napkin_boards_create). Pass the mermaid source. Use for proce | typed |
napkin_diagrams_update | Edit a Napkin diagram: retitle, describe, REPLACE the whole mermaid source, set visibility, or `archived` (true takes it out of the gallery, false brings it back — the recovery move for a diagram crea | typed |
napkin_interfaces_list | List the interfaces in a workspace — small self-contained screens (a custom chat, a control panel, a prototype) that run on their own origin and can call the flows they've been granted. Returns ids, n | typed |
napkin_interfaces_get | Read one interface: its name, the flows it may run (with the published version each is pinned to), and the contents of its files. READ BEFORE EDITING — napkin_interfaces_write matches text exactly aga | typed |
napkin_interfaces_view | See what an interface LOOKS like and DOES right now: the page RUNS from its current files under the same rules as the live page (no web fonts, no remote pictures), and you get a picture plus anything | typed |
napkin_interfaces_create | Create an interface — a small screen of its own the user can open and send to people. Use when someone asks for a custom chat UI, a little tool, or a prototype of how something would feel in their pro | typed |
napkin_interfaces_write | Write one file of an interface. Use `edits` — exact find/replace pairs — which is the SAFEST option and the one to reach for by default: it leaves everything you did not target untouched, and it fails | typed |
napkin_interfaces_publish | Save where an interface is now as a numbered version. Share links point at a published version, so what someone was sent doesn't change while work continues. Do this when the user says it's ready to s | typed |
napkin_interfaces_grant | Set what an interface may run — flows and shims, each pinned to a published version. This is the interface's ONLY reach into the workspace, and it replaces the whole list, so include everything it sho | typed |
napkin_interfaces_grant_data | Set the sheet tables, Ledger metrics and Workbench Tasks an interface may use (ADR 0085, 0086), replacing the whole list. Tables: access read, add (read and add records) or edit (also change and delet | typed |
workbench_tasks_get | One Task in full: its sentence, status, the latest saved plan (the clauses — which run flows, which the assistant handles, who decides at each gate) with the flow and people names the plan refers to, | typed |
workbench_tasks_update | Changes a task's name — the gallery label only. The sentence and plan are versioned and change through workbench_tasks_compile + workbench_tasks_freeze, never here. May return `needs_confirmation`. | typed |
workbench_tasks_delete | Deletes a task. Runs still in flight are stopped (a gate waiting on someone is closed), and its schedule trigger stops firing; past runs stay in history. Check workbench_tasks_get for live runs and sa | typed |
workbench_tasks_set_sites | Sets the full list of sites a Task's machine may reach (example.com, or *.example.com for its subdomains; up to 20), for steps that have to use a site like a person would. It replaces the list, so rea | typed |
workbench_tasks_list | Lists the workspace's Tasks — sentence-orchestrated processes — with their sentence, status, and recent runs (id, status, who a waiting run is on). Use this to find a task the user names ('claims inta | typed |
workbench_tasks_create | Creates a DRAFT Task from a name + sentence. A Task is for work with people in the loop (someone approves, decides or acts on each item before anything else happens) or a specific process mapped in Co | typed |
workbench_tasks_compile | Runs the compiler over a sentence and returns the PROPOSED plan (or repair-grade problems — fix by refining the sentence with the user, not by guessing). Nothing persists. Present the proposal in plai | typed |
workbench_tasks_freeze | Freezes a reviewed plan as the Task's next version and activates it. Pass the EXACT plan object a compile returned — never hand-edit it (change the sentence and recompile instead). Freeze ONLY after t | incomplete |
workbench_tasks_start | Kicks off a run of a Task and returns at once; the run carries on by itself and is live on the task's page. When the task expects an input document (its trigger has an input), pass the user's material | incomplete |
workbench_tasks_run_view | The run's current state rendered as its sentence: what ran (with timings), which path each gate took, what's waiting on whom and for how long, what's coming up. Use whenever the user asks where someth | typed |
workbench_tasks_act | Records THIS user's verdict on a run that is waiting on them — the labels come from the gate (workbench_tasks_run_view shows them via the plan; a wrong label errors listing the real options). Echo the | typed |
routines_list | List the assistant's routines — scheduled natural-language instructions run by the assistant. Returns each routine's id, name, instruction, cadence, delivery, enabled state, and last-run outcome. Chec | typed |
routines_create | Create a routine: something you keep doing for the user on a schedule, one turn per run ("every morning, read these forums, add new questions to the Questions table, and post the count in #support"). | incomplete |
routines_update | Update a routine's instruction, cadence, delivery, the writes each run makes on its own, or its enabled switch (pause/resume). Only pass the fields being changed; `writes` replaces the whole list. Cad | incomplete |
routines_set_sites | Sets the full list of sites a routine's machine may reach on each run (example.com, or *.example.com for its subdomains; up to 20), for a routine that has to use a site like a person would because rea | typed |
rooms_list | The workspace's rooms: where groups of people work together with the assistant and flows. Returns each room's id, name, people and flows, linked folders, open sidebar count, and when it last moved. Us | typed |
rooms_read | What a room has been saying: its catch-up summary (and whether messages have landed since), its sidebars with their outcomes, and the most recent messages as plain lines with who said them. Use it whe | typed |
rooms_post | Posts a message into a room's stream as the assistant, where everyone in the room will see it. Use it when a user asks you to share something with a room, or when a routine's instruction says to deliv | typed |
rooms_add_flow | Adds a Workbench flow to a room as a member, so people can @mention it and it can work on things with you there. The flow must be shared with the workspace and published. Use it after building a speci | typed |
rooms_start_agent_work | Starts the assistant and flows in a room working on something together in a sidebar: they take turns without a person between each, and the result comes back to the room's stream. The flows must alrea | typed |
rooms_create | Creates a room: a shared space where people work together with you, and the person asking is always in it. Add people by name or email (members of this workspace); `private` keeps it to them, otherwis | typed |
rooms_search | Searches the messages in the rooms the person can see, or in one room, newest first. Each hit is a line with who said it, when, the room, and the message id. Use it when someone asks what a group said | typed |
workspace_folders_create | Makes a folder in Home, at the top or inside another folder. Folders gather a client's or a project's work from every tool. Check workspace_folders_browse first so you don't make one that exists. May | typed |
workspace_folders_update | Renames a folder, or moves it (with everything in it) into another folder or to the top. May return needs_confirmation. | incomplete |
workspace_folders_file | Moves things into a folder, or out of every folder with `folderId: null`. Anything from any tool can go in: pass each one's `kind` and `id` as search_workspace or workspace_folders_browse gave them. A | incomplete |
workspace_files_sort | Sorts the files sitting directly in a folder into its subfolders, making a subfolder when two or more belong together; with `folderId: null`, files loose at the top go into the best folder anywhere. T | incomplete |
workspace_credit_get | The workspace's inference-credit position: plan, this month's grant and how much of it is spent, and the purchased balance runs draw on past the grant. Check this before proposing spend-heavy work (ev | typed |
entity_tags_get | Returns the tags on a batch of entities of one kind — the labels galleries organize by. Ids come from the kind's list/get tool or from search_workspace. Use it before entity_tags_set so you replace th | typed |
entity_tags_browse | Without a tag: every tag in use across the workspace with how many entities carry it, most-used first — the vocabulary the team already organizes by. With a tag: everything filed under it across every | typed |
workspace_folders_browse | Without a folder: every folder in the workspace as a tree, each with its id, full path, and how many things are filed directly in it. With a folder (by id or by name): what's inside it — subfolders, t | typed |
entity_tags_set | Replaces the FULL tag set on one entity (an empty list clears it). Read the current tags with entity_tags_get first and pass the merged list — this is not additive. Tags are lowercase letters, numbers | typed |
workspace_files_save_from_chat | Save a picture the user attached in THIS conversation to the workspace's files, in the Home folder "From chat", and get back its file id. Use it when the user wants a picture they sent you used somewh | typed |
workspace_files_read | Read an uploaded file (PDF, Word, PowerPoint, spreadsheet, text) as markdown. Find file ids with workspace_folders_browse (a folder's items of kind workspace_file) or search_workspace. For anything lo | typed |
Badge
Paste into your README. It updates on every verification.
[](https://app.agent-xm.com/a/ai-zerowidth-zerowidth)
Was this agent useful?
Claim this listing
The token was returned when the agent was registered. No token? Prove the domain or repository instead.