SHIP

Make a version the one missions use from their next dispatch. It is rebuilt only if its snapshot is gone; the response says which.

A mission that reached its credit limit pauses until a member lets it continue. This raises the mission's limit by one step and runs the stage that stopped again, so it spends credits: ask the person first. Returns the new limit. Answers 409 when the mission is not at its limit. Requires the missions:run scope.

Hide a finished mission from list_missions and the board. Nothing else changes: unarchive_mission shows it again. Requires the missions:write scope and the config:write capability (an owner or admin).

Create or update the binding for a server the repository declares. roles is the full set of pipeline roles that may use it (reviewer and qa only ever receive read-only tools, and cannot use a server that runs inside the sandbox). transport: 'remote' (the gateway proxies to the server's URL), 'isolate' (the gateway runs the server's npm package in isolation, for a command that needs a secret) or 'local' (the command runs inside the sandbox, no credential). Omit transport and remoteUrl on an update to keep the server the binding is pinned to, with its credential (a roles, tools or credential edit); set them only to bind or re-point the server. Requires the config:write capability.

Build the sandbox's active version, or return the build already running for it.

Delete the per-issue agents/baseBranch override — the mission resolves from ship.yml again.

Create the tracker issue AND start the run in one call, for work that has no issue yet. Pass entryStartAt='builder' with an entryPlan to hand over a plan you already wrote; pass entryStartAt='reviewer'/'qa' with entryPrNumber to hand over an existing build — in which case title may be omitted and the pull request's own title names the mission. This tool calls the SHIP API, documented at https://letsship.ai/docs/api. Requires the missions:run token scope.

Create a recurring agent mission. Firing it — on schedule, or immediately via run_scheduled_task — creates an ordinary tracker issue assigned to the agent, which drives a normal pipeline run: a scheduled task is a stored mission request, not a new execution mode. This tool calls the SHIP API, documented at https://letsship.ai/docs/api. Requires the config:write capability.

Close the mission's open pull request on GitHub without merging it; the mission becomes declined, and no call here reopens it. Requires the missions:write scope.

Delete the stored credential of a private registry (an id from list_sandbox_registries). A sandbox build that installs from that host then gets no credential. Requires the connectors:write scope and the config:write capability.

Delete a sandbox with all its versions and builds. Answers 409 while an agent or a project's default sandbox uses it: point those at another sandbox first (update_project with defaultSandboxTemplateId). Missions that run in it now finish. Requires the agents:write scope and the config:write capability.

Delete a scheduled task and its run history, which no call can bring back. Missions it already started continue. Setting enabled to false stops new runs and keeps the task and its history. Requires the scheduled-tasks:write scope and the config:write capability.

Request teardown of a preview environment (its deployed Worker(s) + every provisioned datastore). Enqueues to the orchestrator; requires project write capability.

Close a notice for the person this token acts for, as the console's close button does. Only a notice with dismissible: true can be closed (a low balance). It stays closed while its id lasts: a low balance that a top-up ends and a later spend brings back has a new id and shows again. Critical notices cannot be closed.

Fetch one agent run: its run record, metric series (CPU/mem/disk over time), and the agent session summaries (role, outcome, cost, sessionId). sessions lists every session of the run's role on the mission; runSessionId names this run's own, so read its log and cost from that one.

Fetch a session's log content from one agent run. part=session is the agent stream-json (reasoning + tool calls); part=system is the container/runner stdout (clone, dependency install, validation gate, git, callback); part=prompt is the assembled input prompt. The role and sessionId are fields of the agent run's own record. A log longer than 40,000 characters returns its end, from a whole line, with a note.

Read the per-issue agents/baseBranch override record for one mission, or null when unset.

Fetch one artifact's metadata + a long-lived signed serving url (open it to view the screenshot/video).

Read the workspace's credit balance by source and expiry, whether a new mission would start now, the per-mission credit ceiling, the project allowance and recent usage. Check it before dispatching work.

Fetch one preview environment's registry row (status, worker name, timestamps).

Fetch one mission. view='summary' (the default, small enough to poll) returns its summary (activity, stage, review/check/test state, PR, paused and pauseSource, cost), its agent runs (sandboxId, role, status, harness, model, cost) and proofRunSandboxId (pass it to list_artifacts as sandboxId for the proof). view='full' adds its stages, events, stats and the plan/review/QA outcomes. pauseSource 'checkpoint:<role>' means a checkpoint holds it: resume_mission approves that stage. Requires the missions:read scope.

Read what needs attention in the workspace, critical first: a tracker connection its vendor no longer accepts (missions cannot start or report back until someone reconnects it), or credits running out. Each notice has a stable id and kind, a message and, when the caller can act, an action URL to hand to a person. A notice the caller dismissed is left out. Check it before dispatching work.

Fetch a single project by its UUID. Returns 404 if the project is not in the caller's org.

A page of a build's log after sequence number `after`. Call again with after = nextAfter until done is true.

How many agents the org's missions are running at once against its limit (null while the org is unclassified), which missions wait for an agent slot and why, and whether every slot on the platform is taken. Read from the platform's once-a-minute capacity check.

Fetch one scheduled task by id: its project, name, prompt, triggers (schedule), labels, template key, skip-if-previous-open setting, enabled state, and next/last run times. An id outside the caller's accessible projects returns not found. For what each fire produced, use list_scheduled_task_runs.

Read what the workspace has set up with SHIP so far, as the console's setup checklist shows it: up to 13 milestones in three groups, taken in order (get started, make it yours, make it autonomous). `activeGroup` names the group to work on now, and each group carries its own count. Each milestone says whether it is reached and, when a console page takes it and the caller's role can, the page that does it. `next` names the first milestone not reached yet. Use it to suggest the next step to a person.

Returns the upstream API status, environment, and version.

Fetch the typed platform-inspection report for a mission, by its issue id. Returns per-section KV/D1/R2 state: task state, retry reason, dispatch error, latest review + QA verdicts, run index, per-attempt provenance, running sandboxes, and session-log heads. Requires the inspect:read scope.

List the agent runs, live and finished, in the caller's accessible projects, newest first. Each run is one agent in its own sandbox. Returns id (the run's sandbox id), issueId, role, harness, status, instance type, and latest CPU/memory/disk metrics. When more runs match, nextCursor is set: pass it back as cursor, with the same filters, for the next page.

List proof-of-work artifacts (QA screenshots/video/traces) for the caller's accessible projects. Each row carries kind, content type, caption, the acceptance criterion it proves, the sandboxId of the agent run that produced it, and a long-lived signed serving url. Filter by issueId to get one ticket's evidence: the artifacts of every run, superseded QA attempts included, up to limit; a note says when more exist. For the mission's proof of work specifically, read proofRunSandboxId from GET /v1/missions/{id} and pass it as sandboxId.

List where the workspace's credits went, newest first: one entry per mission (its start, each further 3 agent-hours, and messages charged before messages became free), per grant, per adjustment and per expiry. Pass nextCursor back as cursor for the next page. Owners and admins only.

List what SHIP sells: the credit packs (credits, the tax-inclusive price in US dollars and the price per credit), the monthly plans under `team.plans` (Starter and Scale: each its credits a month, monthly price, price per credit, which credits added on top also cost, and agents at once), the range of credits a workspace on a plan can add at once, Enterprise under `enterprise` (the minimum yearly credit commitment, the highest and lowest price per credit, and the agents at once at the minimum; contracts are sold by SHIP, not through checkout), what Free and the packs allow (`limits`), plus the trial size. The same catalog the pricing page shows.

List per-mission preview environments for the caller's accessible projects. Returns id, issueId, projectId, prNumber, workerName, and lifecycle status.

Every MCP server binding across the projects you can see in your org: project, server, transport, status, enabled roles, how it authenticates, and the NAMES of the credential fields set (never values). Use it to find where a credential is used; use list_mcp_servers for one project's full detail.

The MCP servers a project's repository declares in its MCP file (.mcp.json by default), each with its binding: enabled roles, transport, status, approved tools, per-role effective tool counts (null when the server runs inside the sandbox and the role gets every tool it exposes), and the NAMES of the credential fields set (never values). Also reports whether the file could be read (configStatus).

List missions in the caller's accessible projects, newest activity first, with total for paging. Each has issueId, title, activity (what it does now), pipelineProgress, review/check/test state, PR, cost and paused. Archived missions are left out. Requires the missions:read scope.

List every organization on the platform with its owner email, member count, and pending invite status. Requires platform-admin (cross_org) access. Cursor-paginated (default page size 50) — feed the response's nextCursor back as the cursor input to reach the next page; a null nextCursor means there are no more pages.

List the projects accessible to the calling principal. Returns id, slug, name, status, createdAt for each.

The org's private package registries sandboxes install from: host, auth scheme, username. Never the secret.

Ready-made sandbox definitions (Python, Java, Go, Rust, Ruby) to create a sandbox from.

Every saved version of a sandbox, newest first, with the active one marked and each one's latest build.

List the org's sandboxes (definitions agents start in), with each one's active version, size and latest build status.

Run history for one scheduled task, each row's status (dispatching/dispatched/skipped/failed) and, once its issue exists, the joined mission progress/cost. A 'dispatched' status means the issue was created and the mission started — never that the work succeeded; read the joined mission state for that. Newest first; when older runs exist, pass nextCursor back as cursor for the next page.

Read-only gallery of curated scheduled task templates — a prepared prompt plus a suggested cadence. A template is content, not a code path: pass its key as templateKey on create_scheduled_task for attribution, or copy its prompt/schedule into a hand-written scheduled task.

List recurring agent missions (scheduled tasks) across the caller's accessible projects — schedule, enabled state, and next/last fire time for each. Pass projectId for the tasks of one project.

Mark a step of the setup checklist completed or skipped for the person this token acts for, as the console's Mark as complete and Skip controls do; open removes the mark. Give step for one milestone, or group to mark every open step of that group (the console's Skip all). A marked step counts as done on that person's checklist and its status says how; reached stays false until SHIP sees the step done. Returns the checklist as it now stands. A token that acts for no person is refused.

Merge the mission's open pull request on GitHub with the repository's own merge method; the mission then becomes done, and the merge cannot be undone from here. Answers 409 with the reason when the pull request cannot merge. On a merge conflict SHIP starts the builder to fix it and merges once the mission is ready again, with no further call. Requires the missions:write scope.

Hold a mission before its next stage. The stage that runs now finishes; no agent is stopped. Use resume_mission to continue. Requires the missions:write scope and a role that can control missions.

Snapshot the bound server's current tools (with their readOnlyHint / destructiveHint annotations) for approval. Approvals of tools that no longer exist are dropped. The binding must be ready; a server inside the sandbox has no gateway tool list. Requires config:write.