Endpoints

Every route an API token can call, by resource, with the scope it needs; and the few that only the portal can.

Reading this page

A route's scope is its resource, the first part of its path after /v1, and its level: read for a GET, write for anything else. So a route nested under a task is a task route: starting a run, POST /v1/tasks/{id}/runs, needs tasks:write, not runs:write. See Authentication for tokens and scopes, and Conventions for errors, pagination and retries.

Every {id} is an id, never a slug. Apart from the catalogue, every route below answers only for your own enterprise: an id from another enterprise is a 404.

Tasks

A task's definition, its versions and schedule, and the runs, memory and recommendations that belong to it. See Tasks, and Tasks over the API for the task as JSON.

Call Scope What it does
GET /v1/tasks tasks:read Tasks, a page at a time, with search and filters.
POST /v1/tasks tasks:write Create a task, with its first version. A task belongs to a role, not a team: a non-null teamId is refused 400 task_team_removed.
GET /v1/tasks/{id} tasks:read The task, its current version and skill, its version list, the teams that have it (teams: every team a holder of its role sits on or leads), its webhook, its definition warnings, and your enterprise's own input values (inputValues, with ignoredInputValues naming any the current version does not take).
DELETE /v1/tasks/{id} tasks:write Delete the task and every version of it. Its runs are kept. A 409 while it has a run under way.
POST /v1/tasks/{id}/copy tasks:write Copy it as a new task of your own: send name and slug, and optionally assigneeRole, which is the original's unless you send one.
GET /v1/tasks/{id}/versions tasks:read Every version, newest first.
GET /v1/tasks/{id}/versions/{versionId} tasks:read One version as it was, with its skill, how many runs used it, and whether it is current.
POST /v1/tasks/{id}/versions tasks:write Publish a new version. Send baseVersionId. Add "visibility": "public" (with catalog:write) to put that version in the catalogue, listed on the task's role once you have published that role, or "private" to withdraw it and record it as left out. Once the task is in the catalogue, every version you save after goes there too, with no visibility; catalogPublication in the answer says whether it did. See Publishing to the catalogue.
GET /v1/tasks/{id}/workflow tasks:read The current version and its skill, on their own.
PUT /v1/tasks/{id}/schedule tasks:write Set its schedule. See Schedules and webhooks.
DELETE /v1/tasks/{id}/schedule tasks:write Remove its schedule.
PUT /v1/tasks/{id}/input-values tasks:write Replace your enterprise's own input values: { "values": { "key": value } }. Every run takes them under what its start gives and over the version's defaults. Works on a clone you cannot edit; refused on a built-in task (os_task_immutable), and for a key the version does not declare (input_undeclared) or a value of the wrong type (input_invalid). See Your own input values.
DELETE /v1/tasks/{id}/input-values tasks:write Clear your enterprise's own input values.
POST /v1/tasks/{id}/runs tasks:write Start a run, with the body as its input.
GET /v1/tasks/{id}/memory tasks:read The notes trained on this task, and its training grants.
POST /v1/tasks/{id}/memory tasks:write Train a note on this task: { "text": "…" }.
GET /v1/tasks/{id}/memory/ask tasks:read Ask memory as this task would. See Memory.
POST /v1/tasks/{id}/memory/train tasks:write Train a note, or a correction, at a layer this task may write. A person may train the task's team (the first team a holder of its role sits on; memory_task_on_no_team when there is none), or the enterprise, here.
GET /v1/tasks/{id}/recommendations tasks:read Self-improvement recommendations for this task.

A task is given to a role, never to one member. A body that creates, changes, copies or clones a task and still names a member in assigneeMemberId is refused with a 400 (assignee_member_removed).

Runs

One run of one task: its status, events, log and cost. See Runs.

Call Scope What it does
GET /v1/runs runs:read Runs, a page at a time, filtered by task, version or status.
GET /v1/runs/{id} runs:read One run, its events and gates, its task, what came before and after it, and its cost. modelStandsInFor names the model its task asked for when the run used another in its place. afterEventId sends only the events since that one.
GET /v1/runs/{id}/log runs:read Its full log, once stored. A 404 (log_not_found) until then.
GET /v1/runs/{id}/os-tool runs:read A short read: its status, task, input and last eight events, the newest later run on the same work (latestRun) and its hand-offs (handOff).
POST /v1/runs/{id}/cancel runs:write Cancel it.
POST /v1/runs/{id}/retry runs:write Retry it as a new run, on the task's current version.
POST /v1/runs/{id}/clear runs:write Take a failed run, or a pipeline that stopped, off Blockers.

Blockers

What cannot move without someone. See Runs.

Call Scope What it does
GET /v1/blockers blockers:read Everything on Blockers, section by section. failedPage and pageSize page the failed runs.
POST /v1/blockers/clear blockers:write Clear every failed run at once: { "section": "failed" }.
POST /v1/blockers/retry blockers:write Retry every run in Blocked (resumes automatically): { "section": "blocked" }. Answers how many were retried and queued, the runs started, and each run refused with its reason.
POST /v1/blockers/cancel blockers:write Cancel every run in Blocked (resumes automatically): { "section": "blocked" }. Answers how many were cancelled and each run refused with its reason.

Waiting

Open work nothing is working on: no run live or queued, no decision waiting, nothing on Blockers, and not finished. Each row is one issue or pull request, named owner/name#<number>. The same rows as the Waiting page.

Call Scope What it does
GET /v1/waiting runs:read Every row, longest waiting first, with how its newest run ended: { rows, total }.
POST /v1/waiting/finish runs:write Mark a row's work finished: { "pipeline": "owner/name#123" }. Recorded on its newest run, as you. No issue or pull request is touched. A 409 (not_waiting) when the work is not on the list.
POST /v1/waiting/restart runs:write Restart a row's work at a step: { "pipeline": "owner/name#123", "task": "<slug>" }. The newest run's own task retries it; another task of its pipeline routes the work there. Returns the new run. A 409 (not_waiting) when the work is not on the list.

Executions

The connected runs of more than one task. See Executions.

Call Scope What it does
GET /v1/executions executions:read Executions, a page at a time. Closed ones only with closed=true.
GET /v1/executions/board executions:read Every lane of the board in one read.
GET /v1/executions/counts executions:read How many executions and runs are running, queued, waiting (and of those, waiting on a gate) and blocked.
GET /v1/executions/{id} executions:read One execution: its runs, links and task graph. Any of its run ids works.
POST /v1/executions/{id}/cancel executions:write Stop every open run in it.
POST /v1/executions/{id}/close executions:write Take a finished execution off the board.
POST /v1/executions/{id}/reopen executions:write Put a closed execution back.
POST /v1/executions/close-completed executions:write Close every execution in the Complete lane under the given filters.

Gates

The calls and questions waiting for your decision. See Gates and tool scopes.

Call Scope What it does
GET /v1/gates gates:read Every gate waiting on you, each with requestedBy: the person who asked for its work (id, name, avatarUrl), or null when nobody of your enterprise did. ?requestedBy=<userId> lists only that person's, and ?requestedBy=none only the ones nobody asked for. Each also carries people: the people it is for (id, name), and ?forPerson=<userId> lists only the ones waiting on that person. Without it, the whole queue returns.
POST /v1/gates/{id}/decision gates:write Decide one: decision is approve, reject or request_changes, with an optional note, answers for questions, and choice (the key of one of the gate's choices) on a gate that offers its own.
POST /v1/gates/chat/{chatId}/decision gates:write Answer the question a chat is waiting on. Name it with gateId, or the newest is answered.

gates:write decides gates, including merges that go live. Grant it deliberately.

Chats

Talking to a member. See Chat and plans.

Call Scope What it does
GET /v1/chats chats:read Chats, the most recently active first. memberId narrows them to one member. A chat opened for a purpose is not listed.
POST /v1/chats chats:write Start a chat with a member: { "memberId": "…" }. Or open one for a single job, { "purpose": "create_task" }: a new chat with the COO (the member who has held the role longest), or with memberId when you send one, whose greeting is already in it. It closes once the task it proposes is applied or rejected. Refused with unknown_purpose for any other purpose, and no_coo when nobody holds the COO role.
GET /v1/chats/unread chats:read How many replies nobody has read yet, in the chats GET /v1/chats lists.
GET /v1/chats/{id} chats:read One chat and its messages, oldest first. limit (1 to 200) returns only the newest. Reading it marks it read.
POST /v1/chats/{id}/messages chats:write Send a message: { "content": "…" }. The member's reply follows in the chat.
POST /v1/chats/{id}/tool-calls/{callId}/decision chats:write Answer a tool call the member is waiting on: allow, always or deny.
POST /v1/chats/{id}/close chats:write Close the chat.
GET /v1/chats/tool-grants chats:read The "Always allow" answers you have given for one member's tools. Send memberId.
DELETE /v1/chats/tool-grants/{grantId} chats:write Withdraw one.

A token's "Always allow" answers are its own, not a person's, and a person's are not the token's.

Planned

Plans

When a member can propose a change to the company as a plan (Chat and plans), you will read it here and decide it as a gate:

Call Scope What it does
GET /v1/plans plans:read Plans, newest first, filtered by status, kind, chatSessionId, planKey or producedByRunId (which also matches a plan whose planKey is that run's id). Each plan carries people, the people its decision is for, and ?forPerson=<userId> keeps only the plans waiting on that person.
GET /v1/plans/{id} plans:read One plan, its items, and the run and gates behind it.

Memory

What the company has learned. See Memory.

Call Scope What it does
GET /v1/memory memory:read The notes, with search and filters, a page at a time.
POST /v1/memory/train memory:write Train a team or enterprise note. No task is required. layer is team or enterprise; a team train sends teamId, and that team must belong to your enterprise.
GET /v1/memory/constellation memory:read The Memory page's map: memories and the links between them, with the same search and filters. limit is how many memories are read, 500 unless named and at most 1,000. status is unavailable when memory could not be read.
GET /v1/memory/recall-health memory:read How often memory could be read over the last 24 hours, by runs and by chat messages.
GET /v1/memory/{id} memory:read One note and its evidence.
POST /v1/memory/{id}/tombstone memory:write Exclude a note from every future answer.
POST /v1/memory/{id}/rate memory:write Rate a note up or down, with an optional reason.
GET /v1/memory/review memory:read The review queue: conflicts, and notes rated down.
GET /v1/memory/review/history memory:read Every review decision made.
POST /v1/memory/review/{id}/resolve memory:write Resolve a conflict by applying a correction: correctionId and a reason.
POST /v1/memory/review/{id}/dismiss memory:write Dismiss an item, with a reason.

Recommendations

Self-improvement's proposed changes to a task. See Self-improvement.

Call Scope What it does
GET /v1/recommendations recommendations:read The recommendations waiting for a decision; taskId narrows them. With view=decided, those decided in the last 60 days.
GET /v1/recommendations/{id} recommendations:read One recommendation, in full.
POST /v1/recommendations/{id}/decision recommendations:write approve or decline, with a reason to decline. Takes an idempotencyKey.

Spend

Caps on what runs may cost, and today's spend. See Spend and models.

Call Scope What it does
GET /v1/spend spend:read Today's spend and runs, and every cap.
PATCH /v1/spend/caps spend:write Set the cap on one layer and layerId. Raising a cap queues paused runs again.
PATCH /v1/spend/enabled spend:write Turn spend limits on or off: { "enabled": false }.

Models

Your model connections and the tiers they resolve to. See Spend and models.

Call Scope What it does
GET /v1/llm/connections llm:read Your model connections, without their keys.
PATCH /v1/llm/connections/{id} llm:write Rename a connection, describe it, set its priority (0–99, lowest first across providers for its owner), or set a subscription login's plan.
PATCH /v1/llm/connections/order llm:write Reorder all connections for one owner across providers, passing connectionIds in order.
GET /v1/llm/connections/{id}/usage llm:read A connection's usage.
GET /v1/llm/bindings llm:read Whether a model key is connected, for the enterprise or, with layer=team or layer=member and layerId, one team or member.
POST /v1/llm/bindings llm:write Connect a key: apiKey, and provider (openrouter, the default, claude, openai or grok). layer (enterprise, team or member) and layerId choose its owner.
DELETE /v1/llm/bindings llm:write Remove a key, named by provider, layer and layerId in the query.
POST /v1/llm/claude/oauth/start, …/complete llm:write Connect a Claude login: start returns the address to sign in at, and complete takes the code and state it gives back.
POST /v1/llm/openai/oauth/start, …/complete llm:write Connect a ChatGPT plan: start returns the address to sign in at and a state. Complete takes that state, and as code the whole address the browser was sent to after signing in.
POST /v1/llm/grok/oauth/start, …/complete llm:write Connect a SuperGrok plan, the same way.
GET /v1/llm/tiers llm:read Which model each tier runs, per provider.
POST /v1/llm/tiers/override llm:write Point a tier at another model the provider offers: provider, tier, model.
GET /v1/llm/models llm:read The models your connections offer, for a task's exact model.

Tools

The systems your members reach, and the connections that let them. See Tools.

Call Scope What it does
GET /v1/tools/bindings tools:read Your tool connections, without their secrets. layer and layerId narrow them. Every connection always carries missingSlotActions: the actions its tasks name under a slot it fills that its action map holds no tool for, each with the tool its Tools directory entry maps it to when the connection is on that entry's own server, otherwise an empty string. {} means nothing is missing; it is never null.
POST /v1/tools/bindings tools:write Connect a tool: an MCP server's address and token, or for a system a member operates in a browser, its sites and start page. slots and slotActions set the slots it fills and its action map; left out, a new connection starts from its directory entry's map.
PATCH /v1/tools/bindings/{id} tools:write Change a connection, or move it to another layer. Only the owner, or a member the owner allows, may change its mustGate list (the tools a task must gate by name). slots sets the tool slots it fills, as a whole list ([] clears it), and slotActions its action map, as a whole object ({} clears it; a blank value clears one action); whoever may edit the connection may change either.
DELETE /v1/tools/bindings/{id} tools:write Remove it.
PUT /v1/tools/bindings/binders/{humanUserId} tools:write Allow a person in your enterprise to connect, change and remove tools on the enterprise itself. Only a signed-in owner may (403 not_enterprise_owner).
DELETE /v1/tools/bindings/binders/{humanUserId} tools:write Take that allowance away again. Only a signed-in owner may.
GET /v1/tools/bindings/{id}/sign-ins tools:read The sign-ins members have saved on a browser connection's sites.
DELETE /v1/tools/bindings/{id}/sign-ins/{memberId} tools:write Forget a member's saved sign-in, on one site or all of them.
GET /v1/tools/oauth/redirect-uri tools:read The redirect address to register with a provider for OAuth.
POST /v1/tools/oauth/start tools:write Start connecting a tool by OAuth. Optional authorizeParams supplies extra authorization URL parameters as a string map; reserved security and permission fields are refused. It finishes in the browser of the person who started it, signed in to the portal, so start it there.
GET /v1/tools/express tools:read The Express tools: systems Zero Human has set up so that you connect them by signing in. Each has a slug, a name and a line on what it does, and may have a category, a rank (higher first; above 0 is featured) and search keywords. A tool's imageUrl is a path on this API.
POST /v1/tools/express/{slug}/connect tools:write Start connecting an Express tool at a layer and layerId. It answers the address to sign in at and finishes in the browser of the person who started it, like oauth/start.

A connection on the enterprise itself is the owner's, and the people the owner allows, signed in: anyone else is refused with 403 ceo_bind_only. A token, or an app connected to your enterprise, connects tools on a team, member, role or task. Neither can connect, change or remove a connection on the enterprise itself, or change a mustGate list, even when the person who approved the app owns the enterprise.

Teams

A charter, a lead, and the members on it. See Teams and charters.

Call Scope What it does
GET /v1/teams teams:read Every team.
POST /v1/teams teams:write Create one: name, and optionally slug, charter, leadMemberId and concurrentRunLimit.
GET /v1/teams/{id} teams:read One team, with its tasks: the tasks of the roles its members hold.
PATCH /v1/teams/{id} teams:write Change its name, charter, lead or concurrent-run limit.
DELETE /v1/teams/{id} teams:write Delete it. Your last team cannot be deleted.
POST /v1/teams/{id}/members teams:write Put a member on the team: memberId, and optionally roleId.
DELETE /v1/teams/{id}/members/{memberId} teams:write Take a member off it.
GET /v1/teams/{id}/members/{memberId}/roles teams:read The roles recorded as held by this member on this team: { "roleIds": [...] }, sorted by id, and [] when none is. A role recorded on none of a member's teams is held on every team they sit on or lead; a role recorded on some is held on those only. A run of a task whose role is recorded here works as this team ahead of the member's other teams (the oldest first, when it is recorded on several).
PUT /v1/teams/{id}/members/{memberId}/roles teams:write Record which of the member's roles they hold on this team: { "roleIds": ["…"] }. It replaces what was recorded, [] clears it, and the answer is the stored { roleIds }. A body that is not a list of role ids is refused 400 invalid_role_ids, a role the member does not hold 409 role_not_held, and a team they neither sit on nor lead 409 not_on_team; an unknown team or member is a 404. Nothing is recorded when a call is refused.

Members

The AI team members, and their inboxes. See Members and inboxes.

Call Scope What it does
GET /v1/members members:read Every member.
POST /v1/members members:write Create one: name, and optionally email and persona.
GET /v1/members/{id} members:read One member.
PATCH /v1/members/{id} members:write Change their name, email or persona. concurrencyCap sets how many tasks they may run at once, and also needs enterprise:write: above 1 only on a plan that allows it (a 402 names the plan), and never above the company's concurrent runs (409). The member read returns concurrencyCap, effectiveConcurrencyCap (what runs on the current plan) and maxConcurrencyCap.
GET /v1/members/{id}/avatar members:read Their picture, as an image.
PUT /v1/members/{id}/avatar members:write Set it: { "dataUrl": "data:image/png;base64,…" }.
DELETE /v1/members/{id}/avatar members:write Remove it.
POST /v1/members/{id}/roles members:write Give them a role: { "roleId": "…" }.
DELETE /v1/members/{id}/roles/{roleId} members:write Take a role away.
GET /v1/members/{id}/emails members:read Their inbox, a page at a time. unreadOnly=true for unread mail only; search= for mail whose sender, subject or text contains the words.
GET /v1/members/{id}/emails/{emailId} members:read One email. Reading it marks it read.
GET /v1/members/{id}/emails/{emailId}/attachments/{attachmentId} members:read An attachment, as the file.

Roles

A job: who holds it, and the tasks it runs. See Roles.

Call Scope What it does
GET /v1/roles roles:read Every role.
POST /v1/roles roles:write Create one: name, and optionally slug. A role belongs to no team: a non-null teamId is refused 400 role_team_removed.
GET /v1/roles/{id} roles:read One role, its holders, the teams it is held on (teams, each with its holders) and its tasks.
POST /v1/roles/{id}/members roles:write Give the role to a member: { "memberId": "…" }.
DELETE /v1/roles/{id}/members/{memberId} roles:write Take it from them.
POST /v1/roles/{id}/tasks roles:write Point a task at the role: { "taskId": "…" }. Its runs then go to the role's holders, on any team or none, and every team a holder sits on has it. This publishes no new version.
DELETE /v1/roles/{id}/tasks/{taskId} roles:write Stop the role running it.

The org

Everything at once: the shape the portal's map draws. See Enterprise.

Call Scope What it does
GET /v1/orgs orgs:read Your whole organisation as one tree: teams, their members, the roles they hold, and the tasks of each.

Enterprise settings

Settings that belong to the whole enterprise. See Enterprise.

Call Scope What it does
GET /v1/enterprise/webhook-secret enterprise:read Which webhook secret is in use and since when: its last characters, never the secret.
POST /v1/enterprise/webhook-secret/rotate enterprise:write A new webhook secret, in this response only. The old one stops working at once.
PUT /v1/enterprise/avatar enterprise:write Set the enterprise's picture: { "dataUrl": "…" }.
DELETE /v1/enterprise/avatar enterprise:write Remove it.
GET /v1/enterprise/concurrency enterprise:read How many runs may run at once.
PATCH /v1/enterprise/concurrency enterprise:write Change it: { "concurrentRunLimit": 3 }.
GET /v1/enterprise/chat-memory-depth enterprise:read How much of memory a chat reply reads, and the depths to choose from.
PATCH /v1/enterprise/chat-memory-depth enterprise:write Change it: { "chatMemoryDepth": "large" }.
GET /v1/enterprise/chat-unprompted-turn-limit enterprise:read How many turns in a row a chat member may take on its own, with nobody writing: 5 unless changed, 0 when off.
PATCH /v1/enterprise/chat-unprompted-turn-limit enterprise:write Change it: { "limit": 2 }, a whole number from 0 (off) to 20.
GET /v1/enterprise/metrics enterprise:read The company's own metrics, the ones that belong to no single team.
PATCH /v1/enterprise/metrics enterprise:write Set them: { "metrics": ["…"] }.
GET /v1/enterprise/changelog-repo enterprise:read The repository that hosts your public changelog: { "changelogRepo": "owner/name" }, or null when you have none.
PATCH /v1/enterprise/changelog-repo enterprise:write Name, change or clear it: { "changelogRepo": "owner/name" } or a clone address without credentials, or an empty value or null for none. An address with sign-in details in it is refused with 400 invalid_changelog_repo. See Workspaces.
GET /v1/enterprise/auto-update-cloned-tasks enterprise:read Whether quiet updates to a catalog task apply by themselves to your linked clones of it: { "autoUpdateClonedTasks": true }. On unless you turned it off. See Enterprise.
PATCH /v1/enterprise/auto-update-cloned-tasks enterprise:write Turn it on or off: { "autoUpdateClonedTasks": false }, the body { autoUpdateClonedTasks: boolean } with a JSON true or false. Anything else, "true" or 1 included, is refused with 400 invalid_auto_update_cloned_tasks and the stored value is kept. Answers with what is now stored.
GET /v1/enterprise/successor-outcomes enterprise:read The outcomes a task's next step can wait on, succeeded first: { "outcomes": ["succeeded", "failed", …] }.

No token can manage API tokens, whatever enterprise:write would otherwise reach: see Portal only.

Catalogue

The teams, roles and tasks you can take into your enterprise. See Task directory.

Call Scope What it does
GET /v1/catalog/tasks catalog:read The catalogue, a page at a time.
GET /v1/catalog/tasks/{id} catalog:read One task in it, with its current version in full: the skill on currentVersion.skillMd, and its tools, guardrails, gates, successors, inputs, spend and version number. currentVersion has the same shape as reading that version on its own.
GET /v1/catalog/tasks/{id}/versions catalog:read Every version of that task, newest first, each marked current or not. No skill text.
GET /v1/catalog/tasks/{id}/versions/{versionId} catalog:read One version as it was, with its skill and whether it is current: compare the version you cloned with the current one.
POST /v1/catalog/tasks/{id}/clone catalog:write Install it, linked to the original. It names no team: it keeps the original's role, every team a holder of that role sits on has it, and it keeps the schedule its publisher runs it on.
POST /v1/catalog/tasks/{id}/copy catalog:write Copy it as your own task: name and slug, and optionally assigneeRole, which is the original's unless you send one. It keeps the original's schedule, as a clone does.
GET /v1/catalog/teams catalog:read Portable team templates, a page at a time, including their charter, teammate role grouping, roles and tasks with tools and approvals. Each task says whether your enterprise already holds a clone of it (clonedByMe, cloneStale, cloneOnVersion).
GET /v1/catalog/teams/{id} catalog:read One team template in full. No publisher member identities or credentials.
POST /v1/catalog/teams catalog:write Publish explicit portable content: name, slug, description, charter and teammates: [{roleIds: [...] }]. Every role must already be a public catalog role and appear in exactly one teammate slot. Requires your plan's catalog publishing flag.
POST /v1/catalog/teams/{id}/clone catalog:write Adopt atomically: name, slug, optional teammateNames (one per slot), taskIds (defaults to all eligible tasks) and moneyCentsDay (defaults to 1000). Creates a private team, fresh teammates and identities on your domain, roles and linked tasks. A role you already have with a template role's slug (your COO's coo, for example) is reused, not refused, and so is a task you already have (of the same original or slug): only the tasks you lack are installed, under their own slugs (reusedTaskIds in the response lists the rest). Every plan can clone, within its existing member limit. Each task it installs keeps its schedule: the one the template suggests, else the one its publisher runs it on, listed as schedules on GET /v1/catalog/teams/{id}. Without schedules in the body, they start on in order while your plan has room, and the rest arrive paused. schedules: [{ "taskId": "…", "enabled": true, "cron": "…" }] says which to switch on, at the time you send. Every other one arrives paused, one you send switched off at the cron you send with it, and switching on more than your plan has room for is refused with nothing installed. A task that needs an input with no default (such as repo) is listed too, with missingInputs: ["repo"], and the review's requiredInputs lists each such input once, with the taskIds that need it. inputValues: { "repo": "acme/app" } gives each value to every new task that declares the field (a task you already had keeps its own values), so its schedule can be switched on. A key no cloned task declares, or a value of the wrong type, is refused with 400 and nothing installed, and switching on a schedule whose input you did not send is refused with 400 input_required. A schedule you send switched off counts as left off on purpose; send it with "leftOff": false when it is off only because its input has no value yet, and it arrives paused at its cron, waiting for that input. The response's pausedSchedules names every schedule the clone left paused: [{ "taskId": "…", "cron": "…", "missingInputs": ["repo"], "leftOff": false }], with the new task's id, the inputs it still lacks and whether you left it off on purpose; it is [] when every carried schedule is on. A schedule paused only for want of an input reads as waiting (schedule.waiting.missingInputs) on GET /v1/tasks/{id} and in waitingSchedules on GET /v1/teams/{id} (each with missingFields, the key, label and type of every input it lacks): set the value with PUT /v1/tasks/{id}/input-values, then switch the schedule on with its normal save. Setting the value never switches it on by itself. slotFills: [{ "slot": "codehost", "bindingId": "…" }] fills each tool slot the tasks declare with one of your connections, without rewriting the tasks. GET /v1/catalog/teams/{id}/review lists the slots, with the connections that fill them and could.
POST /v1/catalog/roles catalog:write Publish your own role's portable name and slug: { "sourceRoleId": "…" }. Its tasks are your public tasks that run as it: the ones already public join it now, and each one you publish later joins it then. Private tasks are never published implicitly. The role's live KPIs are copied onto it, unsigned and with no readings, so a team clone gives them to the roles it creates; a KPI read from a task in the catalogue names that catalogue task, and any other source is left blank. Requires your plan's catalog publishing flag.
GET /v1/catalog/share/roles/{roleId} catalog:read How one of your roles stands with the catalogue: each task that runs as it (listed, outdated when it has a newer version than the catalogue holds, elsewhere when public but not on this role, unlisted when nobody has decided, left_out), the entries still on the role whose tasks moved, were retired or are gone (strays), how many changes the listing is behind on, and how many of the role's live KPIs travel with it (kpis).
GET /v1/catalog/share/teams/{teamId} catalog:read What sharing one of your teams would publish: its roles, each with included and its own listing as above, the roles its entry names that the team no longer has, how many changes the entry is behind on, the team KPIs that travel (kpis), and the role KPIs the included roles bring (roleKpis).
POST /v1/catalog/share/teams/{teamId} catalog:write Share one of your teams, or bring its entry up to date. roleSlugs names the roles that go; the rest are left out, and stay left out when you share again without roleSlugs. Optional name, description, kindOfWork and businessFunction. Each included role you have in the catalogue takes its live KPIs as they stand now, replacing the set it carried, so a changed target updates and a withdrawn KPI goes; a left-out role keeps the set it has.
GET /v1/catalog/roles catalog:read The catalogue's public roles, a page at a time, each with the public tasks on it. Each task says whether your enterprise already holds a clone of it (clonedByMe, cloneStale, cloneOnVersion), as GET /v1/catalog/tasks does.
GET /v1/catalog/roles/{id} catalog:read One role and the public tasks on it, each with your enterprise's clone state.
POST /v1/catalog/roles/{id}/clone catalog:write Install the role and the tasks on it, linked to the originals, in one go: { "teamId": "…" }, the team its holder is seated on. Add createTeammate: true, optional teammateName, taskIds and moneyCentsDay to create a fresh teammate holding the role, with a daily cap (1000 cents by default). Omitting createTeammate keeps the original role-only behavior. memberId instead gives the role to a teammate you already have, who joins the team and keeps their own cap; it cannot be sent with createTeammate. A role you already have with that slug is reused, whatever team its holders sit on. Deprecated tasks are skipped. A task you already have (of the same original or slug) is reused, not copied, and listed in reusedTaskIds; only the tasks you lack are installed, under their own slugs, so cloning the role onto a second team installs nothing again. roleHeldOnTeam in the response says whether anyone on the team holds the role: until someone does, the team does not have its tasks. Each task it installs keeps the schedule its publisher runs it on; a reused task keeps its own. slotFills fills the tasks' tool slots as for a team.

Team and role adoption preserves each task's approval gates and version provenance. Credentials, AI accounts, memory, publisher member identities and run history stay behind. Of the publisher's schedules only the cron comes across, never their timezone or run input: see Schedules on a clone. Selected workflows cannot omit a task they hand off to unless your enterprise already has it. A refusal rolls back the whole adoption. Repeating a successful adoption is refused rather than creating a second team or duplicate tasks. Inspect your teams and tasks after a timeout before retrying. A clone needs your own AI connection and any listed tool connections to run.

Actual team content and the new team sizes per plan are configured separately; these routes do not manufacture customer templates or change plan policy.

Webhooks

What your enterprise's webhooks received, and replaying it.

Call Scope What it does
GET /v1/webhooks webhooks:read Deliveries, a page at a time.
GET /v1/webhooks/{id} webhooks:read One delivery: its request, response, and what followed.
POST /v1/webhooks/{id}/replay webhooks:write Replay it. Send an idempotencyKey.

Without a token

Call What it does
GET /v1/health Whether the API is up, and the version it runs.
POST /v1/webhooks/{enterprise}/tasks/{task} Start a run of a task, named by its slug. Authenticated by your webhook secret. See Webhooks.
POST /v1/webhooks/{enterprise}/gates/{gateId} Decide a gate. Authenticated by your webhook secret.
GET /v1/public/express-tools The Express tools every enterprise is offered: each one's slug, name, description, category, how it signs in, the text of its page, an example task when it has one, and the path of its logo.
GET /v1/public/express-tools/{slug}/image An Express tool's logo, as an image.

Portal only

These belong to a person signed in to the portal, not to a credential. No API token can use them, whatever its scopes:

Routes What they are A token is refused with
/v1/enterprise/api-tokens Creating, rotating, changing and revoking API tokens. 403 api_token_cannot_manage_tokens
/v1/enterprise/connections Apps connected to your enterprise, and revoking them. 403 api_token_cannot_manage_connections
/v1/users The people in your enterprise, what each may reach, and each person's own mailbox address. Owners only. 403 api_token_scope
/v1/enterprises Creating an enterprise, and the pictures of the enterprises a person belongs to. 403 api_token_scope
/v1/auth/me, /v1/auth/enterprise Who is signed in, and which enterprise their session is in. 403 api_token_scope
/v1/consent/enterprises, …/members, …/approve, …/decline The screen where a person connects an app to an enterprise. 403 api_token_scope

A token with no enterprise scope is refused api_token_scope on the first two, before it gets that far. Signing in and out (the rest of /v1/auth) happens in a browser, with a session a token does not have.