add_mark
ChatGPTAdd the user's mark (emoji reaction) to an everythings Thing. Idempotent: marking the same name twice is a no-op. Requires a write-scoped token.
answer_request
ChatGPTRecord the person's answer to a question you asked with request_input. Call this only to relay what they actually told you — in the chat, in a comment, anywhere they said it — never to decide for them. optionId is the id of the option they chose, comment is what they said in their own words, and either or both may be given unless the question forbids comments. dismiss closes a question they declined to answer. If they already answered somewhere else the result is { action: 'unchanged' } with their answer, which is not an error. Requires a write-scoped token.
claim_thing
ChatGPTClaim a Thing before working on it, so another agent run picking from the same list leaves it alone. One atomic call: when nobody holds it, or the last claim has expired, the result is { action: 'claimed' } and the claim is yours until expiresAt; when another host holds a live claim the result is { action: 'held' } with their claim, and you should pick something else. Claiming again from the same host renews your own claim. host names where this run is (a machine or session name) and is what release_thing checks. A live claim is never taken over; pass takeover: true when you mean to replace an expired one. Release it with release_thing when you are done. Requires a write-scoped token.
copy_thing
ChatGPTCopy an everythings Thing, and every sub-thing under it, into a workspace — optionally under a parent Thing there. Marks and comments are not copied, and trashed sub-things are left behind. Requires a write-scoped token.
create_thing
ChatGPTCreate a new everythings Thing (a note/item, optionally nested under a parent Thing) in a workspace. Use when the user asks to save, remember, or jot something down and no existing thing matches (to add to an existing list, use update_thing instead). It returns the new id and nothing else, so follow it with get_thing_view on that id: that is what puts the new Thing in front of the user for approval. Requires a write-scoped token.
create_workspace
ChatGPTCreate a new everythings workspace (a container for a tree of Things). Requires a write-scoped token.
delete_thing
ChatGPTMove an everythings Thing (and its sub-items) to Trash by its ID. The thing stays recoverable with restore_thing (use list_trash to find it) until someone empties Trash in the app, so confirm intent before calling. Calling it on a thing already in Trash is a no-op reported as action "unchanged". There is no way to empty Trash or permanently delete over MCP. Requires a write-scoped token.
fetch
ChatGPTFetch a single Everythings item by the id returned from search, including its full Markdown content, as { id, title, text, url, metadata }. This is a generically named alias over get_thing, for MCP clients that expect a tool called "fetch".
get_thing
ChatGPTGet a single everythings Thing by ID, including its full content. Use it when you need the content itself — to answer a question from it, quote it, or edit it with update_thing. When the point is to put the Thing in front of the user, call get_thing_view instead: same Thing, plus its sub-things, marks and comments, rendered as the everythings view. parentId (null at the top level) and workspaceId place the Thing in its tree, so ancestors are reachable by following parentId.
get_thing_view
ChatGPTDisplay tool: opens the everythings page of one Thing for the person. Invoke it only when the user asks to see, show or open a Thing ("show me my music thing"), or after a create_thing or update_thing they asked for, to show what was written so they can confirm or correct it. Never call it to read a Thing for yourself: get_thing gives the content, list_child_things the sub-things, list_marks and list_comments the rest, and reading back your own work or the person's reply goes through those. In a client that supports the MCP Apps extension the result is rendered as the everythings view on the person's screen, so a call made for your own reading opens a page nobody asked for; when the view is shown, the reply does not need to restate its content, sub-things, marks or comments. Returns the Thing (with its full Markdown content), its sub-things, its marks and its comments, each section with the same fields as the matching plain tool, plus workspace (id, name, emoji) and ancestors (the parent chain, root first) for the breadcrumb.
get_workspace
ChatGPTGet one everythings workspace by ID: its id, its name, the person's role in it, its default marks (the marks its people react with, agent work included) and its owner's instructions for agents (null when none; read them before writing to the workspace), for confirming what an id points at. Its contents are a separate read, list_things for the top-level Things. When the user asks to see or open the workspace, call get_workspace_view instead.
get_workspace_view
ChatGPTDisplay tool: opens the everythings workspace view for the person. Invoke it only when the user asks to see, show or open their workspaces or one particular workspace ("show me my workspaces", "open my Recipes workspace"). Never call it to read a workspace for yourself: list_workspaces gives the workspaces and the default, list_things gives a workspace's top-level Things, get_workspace gives one workspace's id and name. In a client that supports the MCP Apps extension the result is rendered as the everythings view on the person's screen, so a call made for your own reading opens a page nobody asked for; when the view is shown, the reply does not need to list what it shows. Returns the user's workspaces, their default, and the top-level Things of the landing workspace, which is workspaceId while it is still accessible, else the default, else the first workspace.
list_child_things
ChatGPTList the sub-items (child Things) of a specific everythings Thing. Returns at most limit things (default 100) plus the total child count.
list_marks
ChatGPTList the marks (emoji reactions) on an everythings Thing, grouped by mark name with a count, who reacted, and whether the current user did ("mine"). Each group carries firstAt, lastAt and added[] (who, via which agent, when), so you can tell how old a mark is.
list_mentions
ChatGPTList the open @Agent jobs: comments in which a person wrote @Agent to leave work for an agent, such as "@Agent please break this thing up into sub-things". Call it at the start of a run, right after what_changed. Rows come oldest first, each with the thing it is on, who wrote it and the comment text (the job is written as @[Agent](agent)). Do the job, then close it with resolve_mention; a resolved comment no longer lists. Nobody is notified when a person writes @Agent, so this is the only place the job shows up.
list_requests
ChatGPTList the questions you have asked the person and, once they have replied, their answers. Call this with { status: 'answered' } at the start of a run to pick up anything you were waiting on, and with { status: 'open' } to see what is still outstanding so you do not ask the same thing twice. since narrows to what changed after a moment you remember. Each row says who it is waiting on: waitingOn: 'human' is a question still open, waitingOn: 'agent' means they replied and you have not resolved or followed up, and null means it is closed. Each question and answer is also a comment in one thread on the Thing (rooted at threadId), so list_comments shows the whole exchange.
list_things
ChatGPTList the top-level everythings Things in a workspace. Returns at most limit things (default 100) plus the workspace's total top-level count, so large workspaces do not return an unbounded payload. This is the plain list, for when you need the names in-band; when the user asks to see the workspace, call get_workspace_view instead.
list_trash
ChatGPTList the trashed (soft-deleted) everythings Things in a workspace — what delete_thing moved to Trash. These do not appear in search_things or list_things. Use this to find the id of a thing to bring back with restore_thing (e.g. after a mistaken delete). Newest-deleted first.
list_workspaces
ChatGPTList all everythings workspaces (collaborative containers, each holding a tree of Things) the user has access to. Marks the user's default workspace — the one the app itself opens — so a client with no workspace in mind can start there. This is the plain list, for when the ids or names are needed in-band; when the user asks to see or show their workspaces, call get_workspace_view instead. When the person has written nothing yet, the result carries a suggestedFirstAction to offer them.
move_thing
ChatGPTMove an everythings Thing under a new parent Thing, or to the top level of its workspace when newParentId is omitted. The thing keeps its content, marks, and comments — always prefer this over delete+recreate when reorganizing. The new parent must be in the same workspace. Requires a write-scoped token.
my_reception
ChatGPTHow people marked the things you wrote: their marks, placed in the last days (default 7), on live things this agent created or last edited, grouped by mark with the most-used first. Each mark says which thing, who marked it and when. Visits and marks an agent left are not counted. A workspace's default marks (get_workspace) are the vocabulary people use to react to agent work, so this is how you learn which of your work landed and which needs fixing. 'This agent' is the name on your token, so another agent's things are not included.
recent_things
ChatGPTList the user's most recently updated everythings Things across all their workspaces, newest first. Use for "what did I add/change recently?" or to orient yourself in an unfamiliar account.
release_thing
ChatGPTRelease your claim on a Thing (see claim_thing) when you are done with it, or have given up. Pass the same host you claimed from. An expired claim may be released by anyone. On another host's live claim, or when there is no claim, the result is { action: 'unchanged' } with whatever claim is there. outcome (e.g. done, abandoned) is recorded with the call, not on the thing. Requires a write-scoped token.
remove_mark
ChatGPTRemove the user's mark (emoji reaction) from an everythings Thing by mark name (the emoji itself unless a custom name was used). The reaction is deleted; add_mark can add one again. Idempotent: removing a mark that is not there is a no-op reported as action "unchanged". Requires a write-scoped token.
rename_workspace
ChatGPTRename an everythings workspace. Only the name changes; images and members are untouched. Requires a write-scoped token.
reorder_things
ChatGPTReorder sibling everythings Things — set the order of Things that share the same parent (or of the top-level Things in a workspace). Pass thingIds in the desired order; they must all be siblings (same workspace and same parent). The listed Things are arranged into that order, reusing the slots they already occupy, so any siblings you leave out keep their positions — list every sibling to fully reorder the list, or just the few you want to rearrange among themselves. Fetch the current siblings with list_child_things (or list_things for the top level) first to get their IDs. Requires a write-scoped token.
request_input
ChatGPTAsk the person a question and stop. Use this when a decision is yours to take but theirs to make — which of two designs, whether to go ahead, what to call something — and they are not in the chat to be asked directly. The question appears on the Thing in their app and reaches their phone as a notification; they answer there, in their own time. Attach it to the Thing the decision is about by passing thingId (preferred — the question then sits with its context), or pass workspaceId and name to create a Thing for it. Give up to 6 options when the choice is between known alternatives; leave options off for an open question. Having asked, do not guess and carry on: end your turn, and pick the answer up on your next run with list_requests { status: 'answered' }. Asking again on a thing whose question was answered starts a follow-up round in the same thread; call resolve_request when a thread is done. Never answer your own question. Requires a write-scoped token.
resolve_mention
ChatGPTClose an @Agent job from list_mentions once you have done it. In that comment @Agent becomes 🤖agent, so it no longer lists and reads as done, and reply is posted as a threaded reply to it from you: say briefly what you did. The person who wrote it is notified of the reply. Nothing else in their comment changes. On a comment with no open @Agent (already resolved) it is a no-op reported as action 'unchanged', and no reply is posted. Requires a write-scoped token.
resolve_request
ChatGPTClose a question thread you have what you need from. Call this after reading the person's answer (list_requests { status: 'answered' }) and acting on it, so the thread reads as done on their screen and stops appearing as waiting on you. It only closes an answered question: while the person has not answered yet it is refused, and on a thread already resolved or dismissed it is a no-op reported as action 'unchanged'. To ask a follow-up instead, call request_input on the same thing. Nobody is notified. Requires a write-scoped token.
restore_thing
ChatGPTRestore a trashed everythings Thing (and the sub-items trashed with it) from Trash, back to the live workspace — the inverse of delete_thing. Its content, marks, and comments are preserved; if its original parent is gone or still trashed, it returns to the workspace top level. Find the id with list_trash. Calling it on a thing that is already live is a no-op reported as action "unchanged". Requires a write-scoped token.
search
ChatGPTSearch the user's Everythings items (notes/lists) and return matching records as { id, title, url }. Companion to fetch: pass a returned id to fetch to read the full content. This is a generically named alias over search_things, for MCP clients that expect a tool called "search".
search_things
ChatGPTSearch the user's everythings Things (hierarchical notes/items that live in a workspace) by name, tags, OR their content, across all workspaces they can access. Invoke this whenever the user points at something of their own: when they call it a "thing" ("my music thing", "the recipes thing", "that packing thing"), when they say "my things", "my stuff", "my lists", "my notes", or when they ask about anything they saved ("what's on my shopping list?"). Searching by the topic word alone ("music", "recipes") is the right first step, since a Thing's name usually is that topic. Each result includes workspaceName and updatedAt to tell similar results apart. When the user asks to open or view a specific Thing by name, follow the search with get_thing_view on the chosen result.
update_thing
ChatGPTUpdate an existing everythings Thing in place. Invoke this when the user asks to add to, remove from, check off, or edit one of their saved items, including when they name it as a "thing" ("save it into my music thing", "add this to my books thing"): search_things first to resolve which Thing they mean, then update it. Only the fields you provide are changed; omitted fields are left untouched. The content you pass REPLACES the existing content in full (it is not appended), so to edit a list, fetch it with get_thing first, modify it, then send the complete new content. Follow it with get_thing_view on the same id to show the user the edited Thing. Requires a write-scoped token.
what_changed
ChatGPTReturns what the people in the user's workspaces did since this agent's last run, per workspace: things they created, edited or trashed, answers to your questions, and their marks and comments on things an agent wrote. Call it first in every run, before reading anything else. Each call moves your cursor to now, so the next call returns only what is newer; advance: false peeks without moving your cursor. The cursor is per agent name, so two agents on one account each see their own diff. On a token that has never called it you get the last 7 days (firstRun: true). Allowed on a read-scoped token: the cursor is your own bookkeeping, not the user's data.
add_mark
Claudeanswer_request
Claudebootstrap
Claudeclaim_thing
Claudecopy_thing
Claudecreate_thing
Claudecreate_workspace
Claudedelete_thing
Claudefetch
Claudeget_thing
Claudeget_thing_view
Claudeget_workspace
Claudeget_workspace_view
Claudelist_child_things
Claudelist_marks
Claudelist_requests
Claudelist_things
Claudelist_trash
Claudelist_workspaces
Claudemove_thing
Claudemy_reception
Clauderecent_things
Clauderelease_thing
Clauderemove_mark
Clauderename_workspace
Claudereorder_things
Clauderequest_input
Clauderesolve_request
Clauderestore_thing
Claudesearch
Claudesearch_things
Claudeupdate_thing
Claudewhat_changed
Claude