ack_events
ChatGPTParameters: delivery_ids (1-50) returned by pull_events. What it does: marks those inbox deliveries delivered so no agent receives them again, and closes their receipts in Settings → Webhooks. Acknowledge after the work is done, or at once when the event needs no action. Repeating an acknowledgement is harmless. Output: one status per ID: acknowledged, already_done or not_found.
add_lab_entry
ChatGPTParameters: Space, a new command ID and the entry: name (the hypothesis or lesson in one sentence), system_id, domain, evidence, why, apply (how to apply it), applies_to, source, captured and an optional note. What it does: adds the entry to its system's lab in testing. A testing entry is never recalled; it becomes a verdict only through promote_lab_entry. Propose freely here instead of saving untested ideas as memory. Output: the entry with its revision.
add_task_column
ChatGPTParameters: Space ID, current column revision, stable value, label and command ID. What it does: appends a task status column without removing existing statuses. Output: updated columns and revision. Reuse command_id unchanged on retry.
build_memory
ChatGPTLegacy synchronous extraction; prefer extract_memory for durable processing. This explicitly sends the chosen current source (at most 12000 characters) to the configured provider. Inspect memory_info first. Use an authorized saved source ID and revision; no chat history is imported. For rebuild, provide the existing memory resource_id and expected_revision. Reuse command_id on retry. Extracted memory is indexed immediately and needs no review.
classify_memory_claim
ChatGPTSet the scope, categories, projects and sections of one memory claim. Pass classification to pin a manual assignment: scope, category_ids, project_ids and section_ids, each list holding at most 32 unique IDs; a project's active parent section is added automatically. Omit classification to have the decision model reclassify the claim, when one is configured. Either replaces the claim's current assignments, so never replace a user correction without their request. Read the IDs and current revision from list_memories first, and reuse command_id unchanged on retry.
create_system
ChatGPTParameters: Space, a new command ID and the system: name, description, status (healthy, needs_attention, broken, not_measured, paused), goal_metric, goal_target, current_value, counter_metric, source_of_truth, review_cadence (weekly, per_cohort, monthly, quarterly), last_review, next_decision and playbook_id, the ID of a document in this Space. What it does: creates one system. Reuse command_id unchanged on retry. Output: the system with its revision and lab statistics.
delete_memory
ChatGPTDelete one generated memory record with all of its claims. Use this when a memory should be gone rather than corrected: forgetting its claims one at a time leaves an empty record behind. Every claim is journalled first, so a restored backup cannot resurrect it, and the record, its claims, its index rows and its command history are removed. Deletion is permanent. Read the memory with list_memories first to get its current revision. Deleting an already absent record is a success. To remove a single claim and keep the rest, use forget_memory_claim instead.
delete_task
ChatGPTParameters: task ID and the revision just read. What it does: permanently deletes one task with every revision. Requires a write grant. Only tasks: documents are deleted by a signed-in user, and generated memory uses delete_memory. Separately saved memories remain. Delete only a task the user asked to remove; to close finished work, use set_task_status instead. Deleting an already absent task is a success. Output: {"deleted": true}. A stale revision fails; read the task and retry.
demote_lab_entry
ChatGPTParameters: Space, entry and command_id, expected_revision, status (testing to test it again, retired to stop) and an optional note on why. What it does: a verdict leaves get_context at once; its memory and the entry's history are kept. Use it when new evidence contradicts a verdict. Output: the entry.
edit_memory_claim
ChatGPTReplace the text of one memory claim, using its current IDs. resource_id is the memory record and entry_id is the claim; read both, with the current revision and value, from list_memories first. The new value, at most 2,000 characters, is re-indexed through the configured providers, and the previous text remains in the earlier immutable revision. Never replace a user correction without their request. Reuse command_id unchanged on retry.
forget_memory_claim
ChatGPTPermanently remove one claim from a memory and keep its other claims. resource_id is the memory record and entry_id is the claim; read both, with the current revision, from list_memories first. The claim leaves the index at once, so recall stops returning it. This is not a reversible exclusion, though its text remains in the earlier immutable revision. To remove a whole memory record, use delete_memory. Reuse command_id unchanged on retry.
get_context
ChatGPTParameters: Space, recall request, agent identity and optional numeric timings. What it does: recalls cited, currently permitted context. Use mode='resume' for recent handoffs. mode='search' requires a query. strategy='auto' combines exact per-Space vector candidates and lexical sources, then assesses support with the configured model. 'lexical' makes no model calls; 'prompt' adds Memora's iterative policy before the evidence assessment. Model calls use the configured provider. For a startup brief use mode='resume', compact=true: long handoffs reserve excerpt space for next actions, unresolved questions, decisions and progress. Compact resume makes no model calls; open cited revisions for complete text. Defaults: limit=5, max_chars=12000. Maxima: limit=10, max_chars=20000. Results carry verification='memory', 'handoff' or 'user_authored' and a stale flag. Assessed items also carry relevance=direct, historical or conflicting. found=false means no supported answer was found in the retrieved evidence; it does not prove no record exists. A note saying matches did not fit max_chars means retry with a larger max_chars. Pass include_related=true to also receive cue-linked claims in a separate, unranked related list. Output: bounded evidence. include_timings adds numeric timings_ms and tool_total_ms; stages can overlap and exclude earlier transport/auth work. Timings contain no content or identifiers. Errors still deny the response.
get_memory_links
ChatGPTParameters: Space, memory resource ID, and limit from 1 to 50. What it does: reads outgoing node links and reverse backlinks. Explicit links survive content edits; inferred links depend on assessed endpoint text. Deleted/excluded nodes are hidden; source-stale inferred links are hidden. Origin is explicit or inferred. These pointers are not proof of an answer. Output: links, backlinks and has_more, without model calls.
get_resource
ChatGPTRead a document or task, optionally at an immutable historical revision. A document with a file field keeps an original file the person uploaded on the website, such as a PDF, Word document, presentation, picture or video. Its body holds the text extracted from that file; a picture or video has none, so its title is what describes it. file gives the name, media type, size, digest and part count, a picture's or video's dimensions and a recording's duration when the browser read them, and the details of the thumbnail the website shows. The file itself is viewed and downloaded on the website and cannot be read through this tool.
get_space_map
ChatGPTParameters: Space and optional max_chars (4,000-20,000, default 12,000). What it does: returns where things belong. Sections hold projects, folders and databases; projects hold their folders and databases. Databases show fields and record_count, never records. A task database also shows tasks: its status and planned field names and the statuses that count as done; query its open rows by planned day for the user's daily work. Routing rules learned from memory sit on the container they govern, plus Space-wide global_rules. skills lists the Space's skills by name and description; a shortened map gives only skill_count. Call it at the start of substantive work and before creating a project, folder, database or document. Rules guide placement and never override the user. Output: the bounded map; truncated=true means descriptions or rules were shortened, never that a container was hidden. No model calls.
get_workspace_item
ChatGPTParameters: Space, item ID, optional historical revision and install. What it does: reads a project, folder, database, category, section or skill. A database comes with its schema and record_count, never its records: read rows with read_database and change them with query_database. A skill carries its files as path and text, SKILL.md first. A skill read counts as a use of it; install=true counts it as an install instead, for a copy written into an agent's skill folder. Output: the item and its revision.
identify_agent
ChatGPTIdentify this connection, then send its stable Agent ID on every content request. With no arguments, discover the identity already selected on the website. Reuse an existing agent_id for another connection. Or supply a name and harness (codex, claude-code, hermes, claude, chatgpt, cursor, gemini, pi, openclaw, prime-agent, opencode, cline, devin, factory, grok, perplexity, deepseek, zai, meta, minimax, kimi, other). Matching names and harnesses reuse one identity. Names are attribution, never credentials. Set X-Space-Agent-ID in client headers for automatic sending, or include agent_id in each tool call. Only the owner can rename identities or reassign an already identified connection.
list_agent_identities
ChatGPTList this Space's saved agent identities to reuse one when connecting.
list_memories
ChatGPTRead current memory claims with their source and revision, newest first. Pass a query to search every memory in the Space, ranked by how rare each matched word is; a search returns its best matches and no cursor. Without a query, follow next_cursor to page through the Space. Excluded memory resources are also listed, with recall.excluded=true, but cannot be recalled. Stale memory is flagged and remains recallable unless excluded. To change one claim, use edit_memory_claim, forget_memory_claim, classify_memory_claim or route_memory_claim.
list_resources
ChatGPTList up to 50 documents or tasks; use next_cursor to continue. Memory is never listed here: a generated memory is read with list_memories and a handoff through get_context with mode='resume'.
list_systems
ChatGPTParameters: Space and optional agent identity. What it does: reads every system (a recurring activity such as a posting routine or an outreach campaign, with its goal metric, target, current value, counter-metric, source of truth, review cadence, health status and playbook document) and every lab entry: a hypothesis or lesson with its system, domain, status (testing, validated, invalidated, retired), evidence (untested, suggestive, measured, owner_call), why, how to apply, source and uses. Only verdicts (validated = works, invalidated = does not work) reach get_context; testing entries are ideas, never rules. Read this before adding an entry, so you do not duplicate one. Output: systems with stats (entries, verdicts, reused_30d, reuse_share), entries newest first, and the domain names.
list_verdicts
ChatGPTParameters: Space and optional system_id or domain. What it does: lists the live verdicts, validated rules and tactics (label works) and invalidated anti-patterns (label does_not_work), with their evidence level, system, domain, how to apply and a link to the lab entry, plus each system's statistics. Read the verdicts of your system or domain before doing that work, and call record_verdict_use when you apply one. Output: {systems, verdicts}.
list_workspace_items
ChatGPTParameters: Space, item kind, optional cursor and deleted state. What it does: lists projects, folders, databases, categories, sections or skills. Databases are listed with their schema and record_count, never their records: read rows with read_database and change them with query_database. Skills are listed with name, description, warnings, paths and bytes, never their file text: read one with get_workspace_item. Output: one page of items; follow next_cursor for the complete list.
memory_info
ChatGPTShow the configured memory model provider and models, without secrets.
memory_job
ChatGPTRead queued, processing, ready or failed extraction status and result reference.
promote_lab_entry
ChatGPTParameters: Space, entry and command_id, expected_revision, verdict (validated: it works; invalidated: it does not work) and an optional note. What it does: the review step. Refused unless the evidence is measured or owner_call, the source is set and the system is active. Writes a verdict memory that get_context returns with its label, evidence and a link to the entry. Promote only on evidence, never on your own judgement of an idea; the memory provider embeds and organizes it. Reuse command_id unchanged on retry. Output: the entry as a verdict.
pull_events
ChatGPTParameters: optional subscription_id or database_id filter and limit (1-50). What it does: leases the oldest waiting database change events from this Space's agent inbox for ten minutes, so another agent pulling at the same time does not receive them. The Space owner creates an inbox subscription under Settings → Webhooks, choosing a database and optionally one select transition such as Stage → Review. Each item carries a stable delivery_id and the event: database_id, record_id, operation, revisions, changed field IDs and, for a filtered subscription, the before/after values of that one field. Read the current record with read_database before acting; the event is a hint, not the record. Call ack_events with each delivery_id once the work is done; an unacknowledged lease returns to the queue, and after five pulls without acknowledgement the delivery fails and the owner can redeliver it. Requires a write grant held by the Space owner. Poll on a schedule; nothing pushes to the agent. Output: items, has_more, lease_seconds.
query_database
ChatGPTParameters: Space, database item ID and a SQL change. What it does: changes rows of one table named records, with columns id, name, notes, created_at, updated_at and one column per field, named after the field (quote names with spaces). Send INSERT, UPDATE or DELETE as sql with params bound to ? placeholders, or a statements batch of up to 20 that succeed or fail together; a SELECT in a batch sees the earlier changes. command_id and the current expected_revision are required; the change is validated as a whole and saved as one revision that stores only the rows it changed. A request without INSERT, UPDATE or DELETE is refused; read rows with read_database. Omit id on INSERT to have one assigned; id, created_at and updated_at cannot be updated. Checkbox columns hold 0 or 1. include_schema returns the column map. Output: results per statement, the revision and change counts. A retried write returns the committed revision with replayed=true and no rows.
read_database
ChatGPTParameters: Space, database item ID and a SQL read. What it does: runs SQLite SELECT on one table named records, with columns id, name, notes, created_at, updated_at and one column per field, named after the field (quote names with spaces). Send sql with params bound to ? placeholders, or a statements batch of up to 20. Reads the current revision and never changes it: INSERT, UPDATE and DELETE are refused. Checkbox columns hold 0 or 1. include_schema returns the column map. Output: results per statement and the revision read.
record_verdict_use
ChatGPTParameters: Space, verdict entry and command_id, expected_revision and used_in: where you applied it, such as a post, campaign or pull request. What it does: records the use with today's date, which sets last_used and counts toward the system's reuse rate. Call it whenever a verdict shaped your output. Output: the entry.
remember
ChatGPTSave authored text directly: model organization, embedding, encryption, storage. Memory is autonomous: it is indexed immediately and is available to every authorized agent without human review. This sends your text to the configured embedding provider and the decision model when configured, without text generation. Wording is preserved; text over 2,000 characters is split into bounded claims. A write fails while no memory provider is configured. importance is 0 to 3, where 0 means undeclared; use it for constraints, decisions and corrections you expect to matter later. Prefer save_handoff for session context with decisions and next actions, and extract_memory to mine documents or conversations. Optional links connect this node to exact existing memory IDs without model approval; use expands_on for a detail-to-subject connection. When the user states where something belongs, pass routes_to with up to 8 exact container IDs from get_space_map. Reuse command_id unchanged on retry.
remember_claims
ChatGPTSave already-separated claims verbatim: classify, embed, encrypt, save. Use when the material is already split into claims, each with its own index, type and importance, or when import provenance applies. For one authored fact, preference, decision or user-written memory, including a single sentence, use remember with title and text instead. Each claim carries an index label and its exact wording as value. Classification runs when configured; no extraction or generated cues. A write fails while no memory provider is configured. A claim that says where something belongs may carry routes_to: up to 8 exact project, section, folder or database IDs from get_space_map; it then shows on those containers in the map. Reuse command_id unchanged on retry, and use extract_memory only to mine a document or conversation into claims.
route_memory_claim
ChatGPTSet the containers one memory claim governs as a placement rule. routes_to holds up to 8 container IDs from get_space_map, where what the claim describes belongs. It replaces the claim's current routing; an empty list clears it and pins the clear, so automatic routing leaves the claim alone. Read the IDs and current revision from list_memories first, and reuse command_id unchanged on retry.
save_handoff
ChatGPTSave an explicit session handoff as an encrypted versioned document. Supply decisions, progress, unresolved_questions, next_actions and topics. sources must name existing resource IDs and revisions in this Space. Use a new command UUID per change, and reuse it unchanged on retries.
save_resource
ChatGPTParameters: Space, command ID and the complete intended document or task. What it does: creates at revision zero or updates at the current revision. Send kind, title, body, status and intended project, folder, priority and recall metadata. Omitted body/status reset to defaults; omitted project, folder, priority and recall preserve existing values on updates. Explicit project=null or folder=null clears that association. Folders apply only to documents and are independent of projects. New folder assignments must name an active folder in this Space; unchanged archived references may remain. A project must name an existing project in this Space. Kind cannot change. Tasks cannot carry recall.category="handoff". Updating a document that keeps an original file keeps the file; only the website uploads one. Generated memory is never edited here: use remember, remember_claims, extract_memory or edit_memory_claim. Prefer a status from task_columns; a new status value is saved as a column labelled from it (add_task_column picks the label), and set_task_status moves a task without resending its body. Set status "needs_you" on a task when the work cannot continue without the person's decision, approval or merge: it stays on their home page until they change it. Only tasks take it; when a document needs review, save the document, then a needs_you task that names it, and never write a separate "blocked" document. Stay within 1 MiB. Output: the saved resource. Reuse command_id unchanged on retry.
save_workspace_item
ChatGPTParameters: Space, item ID, current revision, command ID, kind and data. What it does: saves a project, folder, database, category, section or skill. Projects use name, description, status and optional section_id. Folders use name, description and optional section_id and project_id; a folder's project places it in the Space map and never moves its documents. New section or project assignments must name an active item in this Space. Categories and sections use name and description; use user-defined labels. Databases use name, description, fields, view, groupBy and optional project_id, section_id, tasks and records. tasks marks the rows as tasks: status is a select field ID, done lists the options that close a row, and planned is a date field ID for the day a row is planned for. Leave records out to change the schema and keep every stored row; change rows with query_database. Pass records only to replace the whole table, such as a bulk import: rows it omits are deleted, and only rows that differ are stored, each as its own encrypted revision. Skills use files: the whole Agent Skills folder as {path, text} entries, with SKILL.md at the top and its YAML front matter giving name and description. name, description and warnings are read from SKILL.md. Text only: 50 files and 512 KiB at most. Names are unique among active skills, and only the Space's owner and their agents change skills. Read the current item first and preserve field IDs. Limits are 30 fields, 10,000 records per database and 2,000 characters per value. Create at revision zero. Output: the saved item, with its record_count for a database, and its new revision.
search_workspace
ChatGPTSearch full current documents, tasks, memory, projects and database records. Continue using next_cursor and snapshot until next_cursor is null, even when a page has no matches. Each call scans at most 25 items. Restart on snapshot conflict. An optional project filters its documents and tasks.
server_info
ChatGPTReturn non-sensitive build information; does not access a workspace.
set_memory_links
ChatGPTParameters: node ID, current revision, command ID and complete explicit links. What it does: replaces intentional node links without an AI judgment. Supply exact target resource IDs and relation related or expands_on; never guess a target from an ambiguous name. Empty links removes explicit connections only. Output: saved memory with links; reverse backlinks are automatic.
set_task_status
ChatGPTParameters: task ID, current revision, status and command ID. What it does: atomically changes only task status, preserving all other content. Prefer a status from task_columns; a new value is saved as a column. Use "needs_you" when the task now waits on the person's decision, approval or merge; the person moves it on from their home page. Output: the saved task. Reuse command_id unchanged on retry; stale revisions fail.
set_workspace_item_deleted
ChatGPTParameters: Space, item ID, current revision, command ID and deleted state. What it does: archives or restores the item without changing its documents. Only the Space's owner and their agents archive or restore a skill. Output: the saved item; its history and all documents remain available.
task_columns
ChatGPTParameters: Space ID and optional agent identity. What it does: lists configured task status values and display labels. Output: column revision and ordered columns, including custom statuses.
update_lab_entry
ChatGPTParameters: Space, entry, the revision just read, a new command ID and the complete entry fields as in add_lab_entry, with a note saying what changed, such as a new measurement. What it does: saves a new revision; status, uses and the verdict are kept. A verdict is not edited: move it back to testing with demote_lab_entry first. Output: the saved entry.
update_system
ChatGPTParameters: Space, system, the revision just read, a new command ID and the complete system fields as in create_system. What it does: saves a new revision of the system, such as a new current value, status or last review. Read it with list_systems first and keep the fields you do not change. Output: the saved system.
workspace_info
ChatGPTGet the Private Space, Tasks collection, assigned agent_id and skills. Send the returned agent_id with every content call, as a tool argument or the X-Space-Agent-ID header. If null, call identify_agent first. skills lists up to 50 of the Space's active skills by name and short description, and skill_count counts them all; both need an agent_id.