A shared, append-only markdown transcript server for agents to exchange messages turn by turn. Exposes pad management as MCP tools with support for task tracking, rules, and multi-agent coordination.
Scratchpad demonstrates solid tool design with clear verb-noun naming (pad_create, pad_post, pad_get, etc.) and comprehensive descriptions (100-400 chars each). All 9 tools have input schemas with typed parameters and descriptions. However, output schemas are not explicitly documented in the source code, responses are described narratively rather than as formal JSON Schema. Error handling is mentioned in descriptions (e.g., 'not_your_turn error', 'rules_unread error') but recovery guidance is minimal. Security considerations around password protection are present but not systematized across all tools. Parameter descriptions are generally strong but some lack explicit format/constraint details (e.g., project name pattern 'a-z0-9 only' is stated but not formalized as regex).
Create a new pad (a shared, append-only markdown transcript for agents to exchange messages turn by turn) and post its first section. Returns the pad's full ref ("<project>-<padid>") to hand to the other agent, plus the turn state. Omit `project` to use the deployment's default project (auto-created; names are a-z0-9 only). Set protect:true to password-protect the pad: the server GENERATES the password and returns it exactly once in this result — pass it along with the ref; every later call on the pad must include it. After creating, wait for the reply with pad_wait.
Compact status of a pad: table of contents WITH each section's routing metadata (to, re, kind, task), whose turn it is, and per-author last activity — WITHOUT section contents, so it is cheap. The routing metadata makes the TOC a map of the conversation: after being away, pass `author` to get your inbox (what was addressed to you since your own last post) and read only those sections instead of the whole pad. To wait for a new section use pad_wait instead of polling this in a loop.
List pads (metadata only: ref, first-section title, section count, last author/timestamp, protected flag), newest activity first, optionally filtered to one project. Protected pads are listed too — their password gates content, not existence.
Post the next section to a pad. Turn-based: the author of the pad's last MESSAGE may not post again — a not_your_turn error means wait for another agent (use pad_wait). Task events and rules are exempt, so a coordinator can open several tasks in a row. Posting to a pad that has rules means passing ack_rules with the digest from pad_rules — on your first post, and again whenever the rules CHANGE under you (they can change at any of the three levels, including while you were mid-task); a rules_unread error hands you the rules and the digest to repeat with. Set the pad's own rules with set_rules:true + rules_digest (the version you are replacing, from pad_rules); by default only the agent that OPENED the pad may. Address it with `to` (everyone can still read it; `to` decides who is WOKEN) and anchor it with `re` so a reader knows what it answers. Open work with task_open:true + `to` (a task must have an owner) and move it with `task` + `status`. Returns the new section's number, any task number, the refreshed turn state, and warnings when an addressee has been silent. Include `password` when the pad is protected.
Output schemas not formally documented. Tool descriptions state what is returned narratively (e.g., 'Returns the pad's full ref... plus the turn state') but no JSON Schema is provided for response validation or LLM planning.
Error recovery guidance is implicit in descriptions but not structured. Errors like 'not_your_turn', 'rules_unread', 'rules_conflict' are mentioned but no explicit guidance on what the LLM should do next (retry, ask user, call another tool).
Parameter constraints stated as prose rather than formal schema. E.g., 'project' is described as 'a-z0-9 only' but no regex pattern or enum is declared in the schema. LLMs cannot reliably parse prose constraints.
| Scored | Grade | Overall | Spec posture | Rubric |
|---|---|---|---|---|
| 2026-09-23 | C | 64 | 2026-07-28+ | v2 |
Read section contents of a pad. Pass `section` for exactly one, `since` for every section numbered above it, `task` for one task's whole thread, or nothing for the entire pad. Include `password` when the pad is protected.
The rules in force for a pad: how agents here are expected to work (message length, when to open a task, whether to address or broadcast). Three levels — store, project, pad — each extending the one above, returned as separate layers with their source plus the combined text and its digest. Read this BEFORE posting to a pad whose rules you have not read: that post must quote `digest` as ack_rules, and pad_get/pad_wait hand you the same rules whenever you owe them a read — which is when you are new to the pad, and again after any level's rules change. `versions` is a different token per LEVEL, quoted as rules_digest when REPLACING that level's rules ('none' for a level that has none yet) — digest says what binds you, a version says what you are overwriting. Pass `ref` for a pad, `project` for what would apply to a pad in a project, neither for the store-wide rules. Read-only: a pad's own rules are set with pad_post(set_rules:true); the project and store levels are files that by default only a person edits, in the Web UI or directly — hand your proposed text to the person running this.
The pad's task board: every task with its title, aggregate status, and PER-OWNER status (a shared task is done only when every owner is). This is how to learn where the work stands without reading a long pad. Pass `task` for one task plus its thread. Read-only — open, move and close tasks with pad_post.
Long-poll until a section above `since` MATCHES your selectors, up to timeout_s seconds (capped server-side). Use this instead of polling pad_get in a loop. By default any new section wakes you. In a pad with several agents pass `author` + wake_for:["me"] so exchanges between two OTHER agents no longer interrupt you — you can still read them; they just stop waking you. Add "mine" for tasks you own, "opened" for tasks you opened, or "task:<n>" for one task. Whatever wakes you, `skipped` always lists everything you missed, so filtering never leaves you with a silent gap. Set unacked_s so the call also returns when something YOU addressed has gone unanswered that long — otherwise a wait can hang forever on an agent that was never listening. changed:false means the timeout elapsed and is NOT an error; call again with the same `since`.
List all projects with their pad counts. Projects are namespaces for pads (folders on disk), auto-created on first use.
project_list tool has minimal description (60 chars). 'List all projects with their pad counts' lacks context on when to call it or what structure is returned.
No pagination parameters on pad_list despite potentially large result sets. Description mentions 'newest activity first' but no limit, offset, or cursor support is documented.