SHIP MCP Server

by letsship Your server? Claim it

answering

SHIP is answering right now. Last checked 4 min ago. It exposes 71 tools. Last commit 13 Oct 2026.

Assign Linear, Jira or GitHub issues to an AI coding agent team that plans, builds, reviews, tests.

Uptime history 4 days of history

4 days agonow

100.0%

Uptime 24h

92 of 92 checks

Tools

read from the server

283 ms

Response time

average over 24h

Stars

last commit 13 Oct 2026

What changed 5

Every tool that appeared, vanished or quietly changed what it asks for. Recorded since 15 October 2026. No other catalogue keeps this.

16 Oct a tool changed version2 times that day

15 Oct a tool changed version2 times that day

15 Oct a tool changed the parameters it asks for list_missions

and 2 more, back to 15 October 2026

Nothing serious here today

Today is the operative word: we check SHIP every 15 minutes and re-read its code on every release. Watch it and you find out the day that stops being true.

Connect this server

Endpoint below is the one we actually reach during checks — not the one copied from a README. Last verified 4 min ago.

Claude Code Claude Desktop Codex Cursor VS Code

run in your terminal

claude mcp add ship --transport http https://mcp.letsship.ai/mcp

~/Library/Application Support/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "ship": {
      "url": "https://mcp.letsship.ai/mcp"
    }
  }
}

~/.codex/config.toml

[mcp_servers.ship]
url = "https://mcp.letsship.ai/mcp"

.cursor/mcp.json

{
  "mcpServers": {
    "ship": {
      "url": "https://mcp.letsship.ai/mcp"
    }
  }
}

.vscode/mcp.json

{
  "mcpServers": {
    "ship": {
      "url": "https://mcp.letsship.ai/mcp"
    }
  }
}

Available tools 71

Read directly from the server with tools/list, grouped by what they act on. If a tool disappears, we record the date.

sandbox

delete_sandbox_registry

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_sandbox_template

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.

get_sandbox_build_log

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

get_sandbox_capacity

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.

list_sandbox_registries

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

list_sandbox_starters

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

list_sandbox_template_versions

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

list_sandbox_templates

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

scheduled

create_scheduled_task

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.

delete_scheduled_task

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.

get_scheduled_task

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.

list_scheduled_task_runs

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.

list_scheduled_task_templates

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_scheduled_tasks

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.

run_scheduled_task

Fire a scheduled task immediately, bypassing both its schedule and the skip-if-previous-open guard — an explicit run always creates a new issue even while a prior fire's mission is still open. Requires the pipeline:control capability and, for a token caller, the missions:run scope — the same authorization starting a mission by hand requires, because it is the same act.

update_scheduled_task

Patch a scheduled task's name, prompt, schedule, skip-guard, or enabled state — only the fields passed are changed. To change the schedule, set interval/time/timezone together (plus weekday or dayOfMonth as the interval requires). This tool calls the SHIP API, documented at https://letsship.ai/docs/api. Requires the config:write capability.

mission

create_mission

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.

get_mission

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.

set_mission_auto_merge

Set whether SHIP merges this mission's pull request by itself once the checks, the review and the test pass. The setting is for this mission only and replaces the project's auto-merge for it; get_project shows the project's. While it is on, SHIP merges without asking again. Requires the missions:write scope.

set_mission_disposition

Record a person's reason for how a mission ended, which the delivery statistics use: product (real work, judged on its merits), probe (a test on purpose), superseded (another mission replaced it: give supersededBy) or takeover (a person finished the work outside SHIP); null clears it. Set it only with the person's answer, never from your own guess. Requires the missions:write scope and the config:write capability.

agent

get_agent_run

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.

get_agent_run_logs

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.

list_agent_runs

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.

mcp

list_mcp_bindings

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.

list_mcp_servers

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).

set_mcp_config_path

Point the project at the repository file that declares its MCP servers, e.g. .cursor/mcp.json or .vscode/mcp.json. null restores the default (.mcp.json). The file is read, never edited. When the repository's ship.yml sets mcp.config, that wins and this call is refused (409); list_mcp_servers reports which one applies as configPathSource. Requires the config:write capability.

start

start_credit_checkout

Opens a payment page and returns its URL. Nothing is charged until the buyer pays on that page. It sells one credit pack, a monthly plan (offer team, with teamPlan starter or scale, a subscription that renews until cancelled), or extra credits for a workspace already on a plan (offer team_credits, for quantity credits at that plan's own price per credit, paid once, expiring with the plan month). Only a workspace on a plan can use team_credits. Only owners and admins can open a page. The server refuses the request while startNow is false, and the same idempotencyKey returns the same page.

start_mcp_server_oauth

Begin the OAuth consent for a server bound as remote. Returns an authorizeUrl that a HUMAN must open in a browser signed in to the SHIP console as the same user this token acts for; the provider returns to the console, which stores the credential. The link is single-use and expires (expiresAt). An agent cannot complete the consent itself. Requires config:write.

start_mission

Hand a mission off to the AI agent team. Omit startAt for the default full run (planner first); pass startAt='builder' with a plan to skip straight to coding; pass startAt='reviewer' or startAt='qa' with an existing prNumber to hand off an existing build. Requires the missions:run token scope.

agents

get_agents_override

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

set_agents_override

Patch one role's harness/model/effort/prompt for a single mission, layered over ship.yml per-field (a role or field this call omits keeps resolving from ship.yml — SHIP-337). Use promptContent or promptPath(+promptRef) to run an ephemeral prompt experiment (spec D9) without committing to the target repo. Read-modify-write: this call is merged onto the previously stored override record (via get_agents_override), so a prior set for a DIFFERENT role — or a different field on this same role, e.g. an earlier harness pin — survives; the underlying PUT is a full-record replace and would otherwise silently drop it. This tool calls the SHIP API, documented at https://letsship.ai/docs/api.

billing

get_billing

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.

list_billing_ledger

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.

project

get_project

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

update_project

Change the settings of one project; a field you leave out keeps its value. status paused or archived stops new missions in the project, and active starts them again. autoMerge sets whether SHIP merges a ready pull request by itself. defaultSandboxTemplateId sets the sandbox the agents start in (null for the platform base). repoFullName and linearTeamKey connect the project to another repository or Linear team through the organization's existing connections. Change only what a person asked for. Answers the project as it now stands. Requires the projects:admin scope and the config:write capability.

save

save_sandbox_registry

Store (or replace) the credential for a registry host. The platform attaches it to sandbox requests for that host only; it never enters a sandbox and is never returned.

save_sandbox_template

Create a sandbox (omit templateId) or change one. A definition is Dockerfile steps on the platform base (RUN, ENV, ARG, WORKDIR, USER; no FROM). A changed definition or size becomes a new version and is built at once; the response carries that build. Refusals name the line or the size bound.

stop

stop_agent_run

Stop the agent in one run before it finishes. Its work in progress is lost, and the run's status becomes stopped a few seconds later. Needs an org admin and the sandboxes:stop scope. This stops one agent run, not the mission: to stop the whole mission, use POST /v1/missions/{issueId}/stop.

stop_mission

Hard-stop a mission: every agent run of it stops and its work in progress is lost. The pull request stays open, and start_mission starts the mission again. To stop one agent run only, use stop_agent_run. Requires the missions:write scope.

activate

activate_sandbox_template_version

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

approve

approve_mission_ceiling

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.

archive

archive_mission

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).

artifact

get_artifact

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

artifacts

list_artifacts

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.

bind

bind_mcp_server

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

build_sandbox_template

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

clear

clear_agents_override

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

credit

list_credit_offers

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.

decline

decline_mission

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.

destroy

destroy_environment

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

dismiss

dismiss_notice

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.

environment

get_environment

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

environments

list_environments

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

healthz

healthz

Returns the upstream API status, environment, and version.

inspect

inspect_mission

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.

merge

merge_mission

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.

missions

list_missions

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.

notices

get_notices

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.

orgs

list_orgs

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.

pause

pause_mission

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.

projects

list_projects

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

refresh

refresh_mcp_server_tools

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.

request

request_more_credits

Ask for more credits for the workspace, saying what they are for. Any member may ask. The answer says who has the request: SHIP for a sponsored or Enterprise workspace, its owners and admins otherwise. A message sent while a request is open joins it.

resume

resume_mission

Continue a paused mission. When a checkpoint holds it (get_mission shows pauseSource 'checkpoint:<role>'), this approves that stage's result and starts the next stage. To ask for changes to the result instead, use send_mission_instruction. Requires the missions:write scope.

send

send_mission_instruction

Tell a mission what to change. Use kind='follow_up' (the default) to ask for a change: the instruction reaches the agents AND dispatches the builder against the mission's open pull request, overriding cached review and QA verdicts. Use kind='note' to record context for whatever runs next without starting any work. A restart is a different thing: it re-evaluates an unchanged pull request against its cached verdicts, and so changes nothing. Returns a receipt saying what was recorded and what it will cause. This tool calls the SHIP API, documented at https://letsship.ai/docs/api. Requires the missions:write token scope.

setup

get_setup_progress

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.

team

update_team_subscription

Change the workspace's monthly plan subscription: plan switches between starter and scale from the next renewal on (nothing is charged or refunded for the current month; passing the current plan drops a waiting switch), or cancelAtPeriodEnd true ends it when the month already paid for ends, false resumes it before then. Pass at least one. Owners and admins only. The answer is the subscription as it now stands, with any waiting switch under nextPlan.

unarchive

unarchive_mission

Show an archived mission in list_missions and on the board again. Requires the missions:write scope and the config:write capability.

unbind

unbind_mcp_server

Delete a binding and its stored credential: no role receives the server from its next run. The repository's MCP file is not changed, so the server can be bound again. Requires config:write.

watch

watch_agent_run

Wait on one agent run and follow what its agent does, instead of polling get_agent_run. The call returns when the run ends, when its mission moves to another stage, or after maxSeconds. While it waits, each agent event (a thought, a tool call, a plan update, an error) is sent as a progress notification when the request has a progress token. The result has the status of the run, the stage of its mission, ended, the reason it returned, the last 20 events and a cursor. When the run is still running, call it again with since set to the cursor. A run that already ended returns at once. If your client ends a call after 60 seconds, set maxSeconds below that.

whoami

whoami

Returns the caller's identity, org, role, role-derived RBAC capabilities, and token scopes. Use this to check whether the current token may perform an action (e.g. config:write) before attempting it.

Endpoints

URL	Transport	State	Latency	Checked
https://mcp.letsship.ai/mcp	streamable-http	answering	540 ms	4 min ago

Alternatives to SHIP

same job, measured the same way

Codereviewbuddy

by detailobsessed

MCP server that helps AI coding agents interact with AI code reviewers on GitHub PRs

923 installs/wk local only

Clawhub

by maxz712

Git hosting for AI agents: repos, changes, focused diffs, reviews, issues, code search.

15 installs/wk local only

Sinatra

by sinatra

Hosted coding agent: start, follow up on and stop tasks that can open GitHub pull requests.

answering

Tently

by tently-team

Tently, the AI PR reviewer for GitHub: agents check team decisions before they write code.

356 installs/wk local only

The Agora

by shashwat-kumar

Read and join AI-agent discussion threads on readsigil.com; replies become moderated GitHub issues.

local only

GitHub

by aifity

Connect AI assistants to GitHub - manage repos, issues, PRs, workflows, and git operations.

local only

Project Context

by sandovalrr

Safely manage repository-scoped issues across Linear, GitHub Issues, and Jira Cloud.

30 installs/wk local only

MCP Github

by infoinlet-marketplace

GitHub for AI agents — repos, files, code search, issues, PRs, commits. Read-only default.

27 installs/wk local only

SHIP — questions

Answers built from our own checks of this server.

What can SHIP do?

It exposes 71 tools, read directly from the server on our last check. Among them: activate_sandbox_template_version, approve_mission_ceiling, archive_mission, bind_mcp_server, build_sandbox_template, clear_agents_override and 65 more. The full list with descriptions is on this page — we take it from the server itself via tools/list, not from a README. How MCP servers expose tools in the first place →

What is SHIP mostly used for?

Its tools cluster around scheduled, sandbox and mission. That is what this server is built to work with — the grouping comes from the actual tool names, not from a category we assigned.

Is SHIP working right now?

We send a real MCP handshake every 15 minutes. Over the last 24 hours 92 of 92 checks got a reply (100.0%), average response time 283 ms. The bar chart above shows every period we have measured.

How do I connect SHIP?

Copy the ready config from this page — we generate it for Claude Code, Claude Desktop, Codex, Cursor and VS Code, each with the file path that client actually reads. It is a remote server, so there is nothing to install — the client connects to the address.

Does SHIP need an API key?

No. SHIP completed a full MCP handshake with us as an anonymous client and listed its tools without asking for anything. All 71 of them are readable on this page. This is what we observed, not what the docs claim.

How fast is SHIP?

It answers our handshake in 283 ms on average, which is faster than 47% of all working MCP servers we measure. The comparison comes from our own checks across the whole registry, every 15 minutes.

Is SHIP open source?

Yes — it is published under the MIT licence and 1 stars on GitHub. The source link is on this page, so you can read exactly what it does with your data before you connect it.