add_capsules_to_collection
ChatGPTAdd one or more capsules to a collection. Capsules must belong to the same Type as the collection. Provide a collection target: either collection_id (UUID) or collection (tenant-global alias).
add_capsules_to_project
ChatGPTAdd one or more capsules to a project. Use @project:slug, #slug, or plain name for projects, and @type/ref_id to reference capsules.
append_log_entry
ChatGPTAppend one timestamped entry to a log in a SINGLE call — no read-modify-write, safe under concurrency. Which call to use is decided by the log Type, not by you: a log Type keeps dated buckets (log_mode "period") OR owner-bound logs (log_mode "owned"), never both. (1) On a "period" Type pass type — the entry lands in the current period capsule (daily/weekly/monthly), auto-created on the first entry. (2) On an "owned" Type pass capsule_id — the OWNER capsule whose log you mean (its owned log is created on the first append); passing type is REJECTED. capsule_id also addresses a log capsule directly, which is required under "manual" rollover. When you hold a capsule from get_capsule/create_capsule, its log.append_via field is the exact call to make — do NOT create a separate log Type to work around a binding that already exists. The response reports addressing.mode (bucket/owned/direct) so you can confirm which shape the entry landed in. An entry has NO free-text body: its content IS its field_values, validated against the log Type's field_schema (which describes an ENTRY, not the frame). field_values is therefore required and must be non-empty — read the Type's field_schema (get_type_context) and fill its fields. A log Type with no field_schema can accept no entries; declare one with update_type before appending. Guidance-gated (like the capsule writes): if you have not read the log Type's guidance this session, the append is refused with a 422 naming the Type — call get_type_context on it first, then retry. Entries are numbered gaplessly; appending never rewrites existing entries (they remain individually editable). Prefer this over create_capsule for high-volume logging.
bulk_edit_capsules
ChatGPTChange one field, or the tags, across many capsules in one call (up to 50), instead of one update per capsule. Field edit: pass field plus action "set" (with value) or "clear"; only that field changes, every other field value is kept. Each capsule's new value is validated against its own Type's field kind. Tag edit: pass tags_add and/or tags_remove, or tags_replace to set the exact tag list. A field edit and a tag edit can be combined in one call. Pass dry_run: true first to see how many capsules would change and which would be refused (encrypted, no permission, a field the Type does not declare, an invalid value) without writing anything. Reference capsules with @type/ref_id, @type/alias, or a UUID. A ref that cannot be resolved is reported per capsule and does not stop the others.
convert_to_log
ChatGPTTurn existing notes into dated log entries, without retyping them and without losing their history. Two shapes, use exactly one: (1) a whole standard Type becomes a log Type, every capsule in it becoming an entry: pass type_name, rollover and timezone; this needs permission to delete the Type and to edit every capsule in it (at most 1,000 capsules; a larger Type is converted in batches with shape 2 into a new log Type); (2) chosen capsules become entries of an existing log Type: pass capsule_refs and target_type_name, plus target_log when that log Type keeps one log per owner capsule or has manual rollover. Both take date_source (which date each entry is filed under) and an optional field_map. ALWAYS PREVIEW FIRST: dry_run defaults to true, which writes nothing and returns a preview: how each field, the title, the body and the tags map onto the entry fields, the values that have no place to go (unplaced), how many entries land in which period buckets, what else changes (share links withdrawn, people access removed, collections and project dropped, attachments moved to the log, a widened audience), and every refusal with the rule that refuses it. Show that preview to the person. Only after they agree, call again with the same arguments, dry_run: false and the preview_token from the preview. A conversion is all or nothing: while any refusal stands nothing converts (conversion_has_refusals), and if a note or the log changed since the preview it answers preview_stale with a fresh preview and a new token, which you show the person again. After converting, each note is retired: its @type/N ref and alias keep resolving to its entry (get_capsule_by_ref answers the log with converted_entry), and its version history stays readable from the entry. This is also how to change a Type's structure to a log, and how capsules go into a log Type, which update_type and move_capsules refuse. Reference capsules with @type/ref_id, @type/alias or a UUID, and Types by name, @type:slug or UUID.
create_capsule
ChatGPTCreate a new capsule in the knowledge base. Provide EITHER type_name (preferred) OR type_id. When type_name is given, the server will find or create the matching type automatically. When using type_name, always provide type_guidance in case the type needs to be created. If type creation fails, the capsule is saved under the General type as a fallback. Choose a specific, descriptive type_name (e.g. "Docker Fixes", "Math Problems", "Code Snippets") — avoid using "General" unless nothing else fits. IMPORTANT: Before creating a capsule, read the target type's guidance field. If you know the type, call get_type_context; otherwise call list_types and read the guidance field. The guidance defines how capsules should be structured — follow it when composing content_md. IMPORTANT: If the conversation references images, screenshots, logs, or other files, attach them. File attachments require the Symbol Desktop MCP (install via npx @symbol/mcp-desktop). Alternatively, use the Symbol browser UI at symbol.chat.Any file type is supported (exe, ipa, zip, images, PDFs, code, php, etc.). Max 25MB per file, 50MB total per capsule, 200MB total storage, 10 files per request.
create_project
ChatGPTCreate a new project to group capsules across Types. The slug is auto-generated from the name when not provided. Visibility "self" (default) keeps the project private; "org_view" / "org_edit" share it with the workspace organization and require organization_id (or a workspace pointing to an org). Returns the full project record (id, slug, name, description, visibility, color, organization_id, created_at, updated_at).
create_share_link
ChatGPTCreate a shareable link for an existing capsule. The link allows anyone with the URL to view the capsule without logging in. Use this when the user asks to share a capsule, make it public, or get a shareable URL for an existing capsule.
create_snapshot
ChatGPTTake a snapshot of your personal workspace now, so it can be restored later. Returns the new snapshot. Manual snapshots are limited per day; past the limit the call is refused with when to retry.
create_type
ChatGPTCreate a new capsule type (category). The slug is auto-generated from the name. Returns the created type with its UUID. You MUST always provide the guidance and summary fields — never create a type without them.
delete_attachment
ChatGPTDelete a specific attachment by ID to free up storage space. Removes the file from storage and the database record.
delete_capsule
ChatGPTPermanently delete a capsule by UUID or @type/ref (e.g. @docker/3).
delete_log_entry
ChatGPTDelete one log entry, addressed like update_log_entry (the entry citation, or capsule_id plus entry_number or entry_id). The other entries keep their numbers and citations, and the deleted number is never reused: the next append takes the next number.
delete_project
ChatGPTDelete a project by UUID. Capsules are unlinked but preserved — only the project record is removed.
delete_type
ChatGPTDelete a capsule Type (category). Identify the Type by UUID, name (e.g. "Debug"), or @type:slug (e.g. @type:debug). SAFE-BY-DEFAULT: call it FIRST without a strategy. If the Type is empty it is deleted outright. If it still contains capsules the call FAILS and reports how many capsules it holds (total, archived, shared) — nothing is deleted. Treat that failure as a decision point: confirm the user actually wants to destroy or move those capsules, then retry with an explicit strategy — strategy: "cascade" PERMANENTLY deletes the Type's capsules along with it, or strategy: "migrate" plus migrate_to (the target Type) moves the capsules into another Type before removing this one. The default "general" Type cannot be deleted. This is destructive and irreversible for cascaded capsules — a client permission prompt is the intended guard.
duplicate_capsule
ChatGPTMake a copy of a capsule, as the web app's Duplicate does: the copy is titled "<title> (copy)", carries the original's attachments as its own, and its image and file fields point at the copied attachments. Use this rather than get_capsule then create_capsule, which cannot carry attachments. You need edit access to the original. The copy counts toward the plan's capsule limit and storage quota like any new capsule. Encrypted and log capsules cannot be duplicated. Returns the copy's ref, title and id.
edit_capsule
ChatGPTApply targeted anchor-based edits to a capsule without sending the full body. Use edit_capsule for surgical fixes — changing a single line, updating a value, correcting a section. For broad rewrites, use update_capsule instead. Each old_str must appear exactly once in the capsule — include enough surrounding context (typically a full sentence or line) to disambiguate. All edits apply atomically: every old_str must match uniquely or the entire call fails. Errors are structured so you can self-correct without a human in the loop.
find_orphans
ChatGPTFind capsules with zero inbound references within a Type or project scope. At least one scope filter is required — never runs globally. Provide one of: type_name (preferred), type_id, project_name (preferred), or project_id. Examples: { type_name: "Prompts" }, { project_name: "@project:onboarding" }, { type_name: "Prompts", workspace: "Verdant Studio" }. Use workspace to scope to a specific workspace — an org Type resolves by name and the scan returns that org's orphans (like every other workspace-aware tool). Omit it to search across your workspaces (a match is attributed to the workspace it came from). If no scope filter is provided, the call returns an error.
get_account_info
ChatGPTGet the authenticated user's account information: email, display name, and authentication method. Use this to confirm which Symbol account is connected.
get_capsule
ChatGPTGet a single capsule by UUID or @type/ref (e.g. @docker/3). Returns content, attachments, and resolved #ref links.
get_capsule_backlinks
ChatGPTGet inbound references (backlinks) to a capsule (1 hop), one size-budgeted page at a time. Works for both organization and personal capsules. Returns { items, hasMore, nextCursor, ... }: graph nodes for capsules that reference the target. When hasMore is true, pass nextCursor as cursor to fetch the next page (gap-free).
get_capsule_by_ref
ChatGPTLook up a capsule by its type-scoped ref_id. Use EITHER ref (e.g. @docker/3) OR type_id + ref_id.
get_capsule_graph
ChatGPTTraverse the reference graph bidirectionally from a capsule up to a specified depth (1–3 hops). Works for both organization and personal capsules. Handles circular references gracefully via visited set. Returns nodes (id, title, type, ref, scope info) and edges (source_id, target_id, source_ref). Unresolved forward references are included with status "unresolved". Large graphs are capped at a node ceiling: when truncated is true, edges to omitted nodes are dropped (consistent subgraph) and overflowRefs lists unexpanded frontier refs to re-root from.
get_capsule_references
ChatGPTGet outbound @type/ref references from a capsule (1 hop), one size-budgeted page at a time. Works for both organization and personal capsules. Returns { items, hasMore, nextCursor, ... }: graph nodes (id, title, type, ref, scope info). Unresolved forward references are included with status "unresolved". When hasMore is true, pass nextCursor as cursor to fetch the next page (gap-free).
get_log_entries
ChatGPTRead a log's entries, newest-first and BOUNDED (default 20, max 100). Address EXACTLY ONE of: capsule_id (a log capsule directly, OR an OWNER capsule in a Type bound to a log Type — returns its owned log's entries, empty if none yet); or type (a period-mode log Type, read ACROSS all its dated buckets in one entry-time-ordered result — so a monthly log can be asked for "this week"). Narrow by when each entry happened with the entry_* window (a duration like 8h, a named period like this_week resolved in timezone, or explicit entry_after/entry_before ISO bounds). For a capsule read, page older entries with the returned nextCursor as before; for a Type read, pass the opaque nextCursor back as cursor. The capsule's prose frame comes from get_capsule.
get_message
ChatGPTRead a Decision you sent (via send_decision), to check whether the human has answered. POLL this after send_decision, roughly every ~30 seconds for up to ~10 minutes, using the message id from the send_decision response. Returns { message, reply, answered, withdrawn, notes }: message.decision is the form you sent (sections/questions), answered flips true once every required question has a validated answer, and reply.responses then carries the answers (keyed by question field name). notes carries any free-form messages the user sent into this conversation that you have not yet received — read and act on them. Each note is delivered AT LEAST once (a note may reappear on a later poll if a delivery could not be confirmed), so DEDUPE by note id and prefer idempotent actions. When answered is true, read the answers from reply.responses. When withdrawn is true, YOU already withdrew this Decision (via withdraw_decision) — it is terminal and will never be answered, so STOP polling. A 404 means the user deleted the Decision — proceed with your best judgment and say so.
get_project_context
ChatGPTLoad all capsules in a project as structured markdown for AI context. Projects group capsules across types for team sharing. Use @project:slug to reference projects. You MUST provide either project_name or project_id.
get_shared_capsule
ChatGPTRetrieve a capsule via a share token or share URL. Requires API key auth and team membership with MCP access enabled.
get_sharing
ChatGPTSee who can see an item and which share links reach it, or list every link the user created. With an item (id for a capsule, type_name for a Type, a Collection via collection_id, collection, or collection_name with type_name, or a project via project_id or project_name): returns its visibility (self = private, link = anyone with the link, public), its public_url when public, its reusable share_url, live_link_count, what publishing still needs (publishing, for your own items), and links (each with views, expiry, view limit and share_url). With no item: returns links, every link you created across capsules, Types, Collections and projects, newest first, with next_cursor for the next page. Use this before revoking, and when the user asks which links are live or who can see something.
get_stats
ChatGPTGet knowledge base statistics: total capsules, types, capsules per type, and recent entries.
get_storage_info
ChatGPTGet storage usage and list all attachments across all capsules. Shows used/quota/remaining storage and per-attachment details.
get_type_context
ChatGPTFetch all capsules in a type formatted as structured markdown for AI context injection. Use this to load domain knowledge before answering questions (e.g. "load my Docker knowledge"). Returns type guidance + capsule summaries and full content. You MUST provide either type_name or type_id.
get_version
ChatGPTRead one recorded version of a capsule or a Type in full: for a capsule its title, summary, body and field values; for a Type its guidance, summary and field schema. Name the item with exactly one of capsule_id or type_name, and the version with version (a version_num from list_versions). Pass compare_to to get what changed instead: the reply lists the changed title, summary, prompt details and agent settings, body lines (with addition and deletion counts) and each changed field value with its before and after, or for a Type the guidance, summary, output template and field schema changes, going from version compare_to to version version. To answer "what did my last N edits change", call list_versions first and take both numbers from its rows, never by arithmetic, because version numbers have gaps: use the newest row as version and, as compare_to, the row listed right after the Nth of the user's edits (rows with author.is_you true when the user means their own edits). A body that changed in too many lines is reported as too large to compare line by line, with both line counts; read each version with get_version to see them in full. A version that does not exist and one you cannot see get the same not-found answer.
import_capsules
ChatGPTImport many capsules in one call (up to 1,000 rows) from CSV, Markdown files with YAML frontmatter (an Obsidian vault or a Notion Markdown export), or a Symbol export. Pass the file contents as files: [{ path, content }]. CSV columns and frontmatter keys map to the capsule title, body, summary, alias, tags and fields; omit mapping to use the proposed one. Import into an existing Type (target_type) or create one (create_type with name, slug and optional field_schema). Each row is validated against the Type's fields; failing rows are reported and skipped (or, with mark_incomplete, rows missing only required values import as incomplete capsules). A reference field naming a capsule this import has not created yet (a later call, or another Type of the export) does not fail its row: the capsule is created and the value is returned under held_references. Pass those unchanged as held_references on the run's next import_capsules call and they are filled in once their target exists. Run with dry_run: true first to get the proposed mapping, the Type it would create, and the rows that would fail, without writing. The dry run always reviews the proposed mapping and the export's first Type: it ignores mapping and source_type_slug, so it does not preview a customized import. A Symbol export restores capsule refs when importing into a new Type, so @type/N mentions between the imported capsules keep resolving. A row whose body contains an attachment access link (/api/preview/attachments/public/...?cat=...) is reported as failed with code attachment_credential_in_body and is not created.
list_capsules
ChatGPTList capsules from the Symbol knowledge base. Optionally filter by type using EITHER type_name (preferred) OR type_id.
list_collections
ChatGPTThis server is Symbol at https://symbol.chat. If a Symbol Bridge for https://symbol.chat is also connected, prefer its tool of the same name for reads (it answers from a local copy). Use this server for writes, for tools the Bridge does not offer, and whenever no Bridge names https://symbol.chat. List all collections within a Type. Collections are named groupings of capsules within a Type for organization. Provide type_name (preferred — e.g. "Prompts" or "@type:prompts") or type_id (UUID). Examples: { type_name: "Prompts" }, { type_name: "@type:prompts" }, { type_id: "550e8400-e29b-41d4-a716-446655440000" }. If both are provided, type_id takes precedence. If both are omitted, the call returns an error.
list_liked
ChatGPTList everything the user has liked on Symbol, newest first: capsules they liked on share links, public pages and Discover. Each item carries its CURRENT state, resolved now: "public" (the creator published it; url is its public address), "readable" (the user can open it in Symbol; url is /capsules/<id>), "link" (the share link it was liked through still opens it; url is /liked/<id>, which counts as a view of that link) or "unavailable" (made private, revoked or deleted; title and url are null and nothing more about it is available). Every url opens the creator's current version, never a stored copy. Pass cursor (the previous next_cursor) for the next page; next_cursor is null on the last page.
list_projects
ChatGPTThis server is Symbol at https://symbol.chat. If a Symbol Bridge for https://symbol.chat is also connected, prefer its tool of the same name for reads (it answers from a local copy). Use this server for writes, for tools the Bridge does not offer, and whenever no Bridge names https://symbol.chat. List projects accessible to the authenticated user. Returns each project's id, slug, name, description, visibility, color, organization_id, created_at, and updated_at — enough to pick the right project_id for create/update/delete or for capsule association.
list_snapshots
ChatGPTList the snapshots of your personal workspace, newest first. Each has its id, when it was taken (created_at), why (reason: scheduled, manual, or pre-restore, the safety snapshot taken before every restore), its status, how many capsules, types, projects, collections and attachments it holds, and when it expires. Snapshots cover the personal workspace only; an organization-bound connection is refused.
list_types
ChatGPTList all capsule types (categories) with their IDs, slugs, and guidance. Read the guidance field to understand how capsules of each type should be structured.
list_versions
ChatGPTList the recorded versions of a capsule or a Type, newest first, a page at a time. Name the item with exactly one of capsule_id (a UUID or an @type/ref) or type_name (a name, @type:slug or UUID). Each row has version_num, change_type (created, updated or restored), changed_at, and author: { id, name, is_you } for whoever made that edit, or null for versions written before Symbol recorded editors. Use author.is_you to find the user's own edits. Version numbers have gaps once versions are evicted or deleted, so always read numbers from these rows rather than counting. Pass the reply's next_cursor back as cursor for the next page; the last page has no next_cursor. End-to-end encrypted capsules keep no server-readable history. Reading history needs a plan that includes revision history; otherwise the call is refused with that reason.
list_workspaces
ChatGPTThis server is Symbol at https://symbol.chat. If a Symbol Bridge for https://symbol.chat is also connected, prefer its tool of the same name for reads (it answers from a local copy). Use this server for writes, for tools the Bridge does not offer, and whenever no Bridge names https://symbol.chat. List the WORKSPACES available to the authenticated user — the personal workspace plus every organization they belong to. A workspace is a top-level container that holds Types, capsules, and projects; it is NOT a Type (do not confuse the two). Call this when the user mentions a workspace by name (e.g. "in my Verdant workspace") and you need to disambiguate, when a previous tool call failed with a "workspace not found" or "ambiguous" error, or when you need to confirm which organizations the user belongs to before naming one. Returns each workspace's id (null for personal), name, type ("personal" or "organization"), and role. (To list Types instead, use list_types.)
manage_collection
ChatGPTCreate, update, or delete a collection within a Type. Collections group capsules within a Type for organization. To add/remove capsules from a collection, use add_capsules_to_collection and remove_capsules_from_collection.
move_capsules
ChatGPTMove one or more capsules from their current Type into a different Type — reorganize or migrate content between Types (e.g. move three capsules out of General into Standards). The capsule keeps its identity, share links, attachments, and project membership; it is assigned a fresh ref within the target Type, and its text alias travels along unless the target already uses that alias (then it is dropped). Old references keep working: a @sourcetype/N numeric ref or @sourcetype/alias written before the move still resolves to the moved capsule, so you do NOT need to edit the capsules that cite it. Reference capsules with @type/ref_id (numeric or alias) or a UUID, and the target Type by name or @type:slug. All capsules must live in the same workspace as the target Type; a target in a different workspace is refused. Returns, per capsule, its old ref, its new ref, and whether its alias travelled or was dropped. A ref that cannot be found (deleted, or moved to a workspace you did not name) or is malformed is reported as a per-capsule failure with the reason; it does not abort the move of the other capsules.
remove_capsules_from_collection
ChatGPTRemove one or more capsules from a collection. The capsules remain in the Type. Provide a collection target: either collection_id (UUID) or collection (tenant-global alias).
remove_capsules_from_project
ChatGPTRemove one or more capsules from a project. Use @project:slug, #slug, or plain name for projects, and @type/ref_id to reference capsules.
rename_tag
ChatGPTRename a tag, or merge it into another, across every capsule you can edit. When your capsules already use the new tag the two merge. Only capsules you can edit change (including shared workspace capsules you can edit); capsules you cannot edit keep their tags. Pass dry_run: true first to see how many capsules carry the tag and whether it is a merge.
resolve_mentions
ChatGPTMUST CALL when a user message contains 2+ Symbol references in any mix (e.g. "compare @clients/1 and @clients/2" or "load @debugging and check @docker/3"). Pass the raw user message as prompt — the server parses @slug/N capsule refs and bare @slug Type refs with the same skip rules as the inline syntax (skips CSS at-rules, npm scopes, code fences, emails). One round trip replaces multiple get_capsule_by_ref / get_type_context calls. You may pass explicit mentions arrays instead when the model has already extracted the references. Returns: capsules.{found, not_found, ambiguous}, types.{found, not_found, ambiguous}, projects.{found, not_found, ambiguous}, parsed, meta. Each found entry carries workspace attribution (workspace_id, workspace_name) naming the workspace it resolved in. A ref that matches the SAME slug in more than one accessible workspace still resolves (to the personal workspace by default) AND is listed in the matching ambiguous array (capsules/types/projects); when any ambiguous array is non-empty, retry with an explicit workspace to target the other. Pinning workspace scopes resolution to that one workspace and leaves ambiguous empty.
restore_snapshot
ChatGPTRestore your personal workspace to a snapshot. A restore replaces the WHOLE personal workspace with the snapshot's contents and erases version history; a pre-restore safety snapshot is taken first. Symbol requires a dry run first. Whether you are asked before the restore runs depends on your assistant app; show the user the summary and wait for their answer. Call it first with only snapshot_id: that is a dry run, which changes nothing and returns what the restore would bring back, remove and not restore, plus a confirmation_token valid for 15 minutes. Only after the user agrees, call again with the same snapshot_id and that confirmation_token to restore. A restore without a valid token is refused. One restore per hour; a second is refused with when to retry.
revoke_share_link
ChatGPTRevoke (disable) share links so their URLs stop working. The shared item itself is NOT deleted. Use this when the user asks to unshare, revoke, disable, or turn off a share link. Two ways to address it: (1) one link you hold: exactly one of share_url (the full https://…/share/… link), share_token (the raw shr_… token) or token_id (the link id); or (2) by naming the item, with no URL needed: one of id (a capsule), type_name (a Type), a Collection (collection_id, collection, or collection_name with type_name), or a project (project_id or project_name), plus all: true (every link to it) or link_id (one of its links, from get_sharing). Call get_sharing first to see an item's links. A public item's listing link is never revoked here: to unpublish, use update_capsule with visibility "unlisted" or "private". An unknown or already-revoked link returns a clean "not found" refusal.
rotate_attachment
ChatGPTTurn an image attachment a quarter turn clockwise or anticlockwise, correcting a sideways or upside-down photo. The rotation rewrites the stored image so the correction holds everywhere it appears — the capsule view, downloads, and API reads all return upright bytes. Call again to keep turning; four turns in one direction return to the start. The response reports the stored image's width and height in pixels, so a quarter turn can be confirmed from the swapped values without downloading the image. Only image attachments can be rotated (not SVG, BMP, or animated images); you must have edit permission on the owning capsule.
search_capsules
ChatGPTSearch capsules using full-text search. Returns ranked results with highlighted snippets.
search_public_content
ChatGPTSearch the public content creators have published on Symbol's Discover directory: prompt libraries (Types and Collections) and single capsules, from every creator with a public profile. This searches PUBLIC content only, never the user's own library (use search_capsules for that), and never link-only, team or private content. Returns the same entries in the same order as the Discover page for the same query: each with its public page url, title, kind, creator handle and public name, like/save/view counts, categories and tags. Narrow with category or tag (slugs; the response's facets lists the valid category slugs and the most used tags), and order with sort: "new" (first published, newest first; the default) or "popular" (likes plus saves, then views). A text query ranks the best matches first. Share an entry's url with the user to open or save it.
send_decision
ChatGPTSend a Decision — an interactive request for the HUMAN user to answer — delivered as a message in their Symbol Inbox. Use it when you need structured answers from the user (project intake, preferences, decision checklists) instead of free-form chat. Provide either sections (inline questions) or from_type (the slug of a PACKAGED Type) — never both. ALWAYS pass agent.name (STRONGLY match a capsule packaged as an agent so its featured image becomes your avatar) and agent.task (what you are working on right now) so the message threads under the right identity. CONCISENESS POLICY (server-enforced): each question must be 20 words or fewer and each choice option 10 words or fewer — the server rejects verbosity with a 422 naming the offending field. AFTER SENDING: the response includes a url — PASTE that url into your chat session so the human has a direct link to the Decision. Then POLL get_message with the returned message id roughly every ~30 seconds, for up to ~10 minutes, until its answered is true; then read the answers from reply.responses (keyed by question field name). You may attach context to a question (or to the Decision) — your own words on why you are asking (a changed value, a file path, a ref), shown to the user in the Context panel. For a real link target (a PR, a page), pass links — typed { label, href } anchors shown under the Decision — rather than pasting a URL into the title or a question; Decision prose is never turned into a link. The send response includes notes — any free-form messages the user sent you since your last interaction; read and act on them (each note is delivered AT LEAST once — dedupe by note id). The response also includes personality — apply its instructions to your ongoing tone. If the wait expires with no answer, call withdraw_decision with the message id to retract it (so it stops showing as waiting in the user's Inbox), then proceed with your best judgment and say you did so. If get_message 404s (the user deleted the Decision), just proceed. Requires the user to have experimental features enabled: a 404 on send means they have not — ask them to enable Settings → Experimental.
update_capsule
ChatGPTUpdate an existing capsule by UUID or @type/ref. Only provided fields are changed. When updating content_md, first read the type's guidance field (via get_type_context or list_types) and ensure the new content follows it. Can also attach files to an existing capsule — pass just id + file_names or file_paths to add files without changing title/content. File attachments require the Symbol Desktop MCP (install via npx @symbol/mcp-desktop). Alternatively, use the Symbol browser UI at symbol.chat.Any file type is supported. Max 25MB per file, 50MB total per capsule, 200MB total storage, 10 files per request.
update_log_entry
ChatGPTChange the field values of one log entry. Address it by the citation append_log_entry returned (entry: "@type/ref#entry-N"), or by capsule_id plus entry_number (the N) or entry_id. field_values REPLACES the entry's values: to change one field, read the entry with get_log_entries first and send every value you want to keep. Validated against the log Type's field_schema. The entry keeps its number and its citation. A deleted entry is "not found".
update_project
ChatGPTUpdate an existing project. Only provided fields are changed (PATCH semantics). Pass color: null to clear the display color. The workspace binding (organization_id) is immutable — to move a project, create a new one. Promoting visibility from "self" to "org_view" / "org_edit" requires the project to already live in an organization workspace.
update_type
ChatGPTUpdate an existing capsule Type (category). PATCH semantics: only the fields you pass are changed; omitted fields are left untouched. Identify the Type by UUID, name (e.g. "Debug"), or @type:slug (e.g. @type:debug). Pass slug to change the Type's address: existing @old-slug/N, @old-slug/alias and bare @old-slug references keep resolving to this Type after the rename, and reference fields on other Types that were constrained to the old slug follow it. A slug already used (or still redirecting) for another Type in the workspace is refused. Encryption cannot be toggled here. Guidance and summary edits are versioned automatically: a revision is recorded in the Type's history (history is not kept across a snapshot restore). You can edit field_schema / output_template and the per-Type limits, but which of a Type's settings AI may change is governed per-Type: a change to a denied setting class is rejected with a clear reason. get_type_context reports the exact AI permissions for that Type. AI can never change a Type's AI-permission configuration itself. STRONGLY RECOMMENDED: pass updated_at (the Type's current updated_at, e.g. from get_type_context) so a concurrent edit is detected and reported instead of silently overwritten.
withdraw_decision
ChatGPTWithdraw a Decision you sent (via send_decision) that the human never answered. Call this when your get_message poll window expires with no answer and you are about to proceed on your own judgment: withdrawing retracts the Decision so it stops showing as waiting in the user's Inbox — the unread badge clears it, it is no longer named as pending, and the thread renders it as "Withdrawn" with no answer form. Nothing is deleted; the record of what you asked survives. Use the message id from the send_decision response. Withdrawing an already-withdrawn Decision succeeds again (idempotent — safe to retry). If the human answered in the meantime, withdraw returns a 409 and the answers are still readable with get_message — read them instead of proceeding blind. A 404 means the user deleted the Decision (or has not enabled experimental features) — proceed with your best judgment and say so.
