Product · Ship
Closed betaThe shipping floor for AI‑native engineering teams.
Ship runs the loop from ticket to merged PR — driven from your own agent over MCP. Seven named states, event-driven dispatch off your tracker, versioned specialists that fire on a transition, not a clock. Repo, tracker, policy, knowledge, and evidence — one workspace, one accountable loop. Built by the team that wrote the book on it.
Ship ships Ship
The team that built Ship runs its delivery on Ship.
The engine runs its own delivery loop — tickets, planning, PRs, merges — through the same workspace this page describes. The numbers below come straight from that repository.
1,214
Engine commits since April
288k
Lines of code
385
Commits, last 30 days
50
PRs merged, last 30 days
Cadence · measured from Ship's own delivery
Cadence as a load‑bearing metric, not a bumper sticker.
The numbers an SRE‑literate buyer actually reads — measured from the engine shipping its own changes through this loop. Deployment frequency and lead time are real and verifiable; we don't publish change‑fail or recovery numbers we can't yet measure cleanly. A missing number beats a flattering one.
17
PRs shipped, last 24h
Elite10 min
Median lead time, open → merge
Elite85%
PRs merged under an hour
Live1
PRs in flight right now
LiveDeployment frequency and PRs‑in‑flight read live from the workspace; lead‑time figures are the median over the last 40 merged pull requests on ElMundiUA/ship. Pulled, not rendered — so the promise behind each number is one you can re‑run.
What Ship is
A loop with named owners, fenced agents, and a paper trail.
Six properties that compose into one operating model. None of them are features in isolation; together they're what makes the loop legible to a CTO at a glance.
The loop
Seven named states from ticket to merged PR
Backlog → Planning → Executing → Reviewing → Awaiting input → Blocked → Closed, connected by a Default flow. Every ticket is in exactly one. A new hire reads the board on day one.
Named owners
Specialists, not roles in spirit
Planning bundle, Developer, Validation bundle, Reviewer, DevOps, Designer, Clarification specialist. Each stage names which agent acts and which artifact it produces.
Routines
Routines that fire on a transition, not a clock
Delivery dispatches when a ticket's state changes — event-driven, off your tracker. A few jobs stay time-scheduled (daily digest, retro, nightly knowledge); self-heal was retired once the contract got boring enough not to need it.
Evidence
Audit trail as a side-effect, not a project
Every decision, retrieval, and outcome captured as an artifact. The Audit log filters by surface and time. Compliance is grep, not a meeting.
Knowledge
Curated facts the agents actually read
Per-workspace buckets backed by Lighthouse. Import sources — repos, web pages, file upload, Notion/Confluence — refresh on a schedule. Nothing publishes silently; every fact passes through review.
Owner-first
Humans stay accountable
Clarifications and approvals are worked through your own agent and the /approve page — no mailbox to babysit. Resolve, approve, or dismiss; every disposition is logged. The merge is yours.
The surfaces, in order
Drive from your agent. Work the decisions. Walk the pipeline.
Your own agent over MCP is the front door; the console is the thin trust surface behind it. A few views carry the rest of the day — the same ones, in the same order, every morning.
Workspace home
Ask your agent what's in flight
No dashboard to monitor. Ask your own agent over MCP and it reads back the priorities feed: what's active, what's waiting on you, the last thing that shipped. If the answer is quiet, the system is quietly doing nothing — that's a finding, not a feature.
Read the docsDecisions
Approvals, not a mailbox to drain
Only items that need a human: clarifications, approvals, blockers. Your agent surfaces them and you sign off in the same breath — or open the web /approve page for the deliberate ones. Every disposition is logged. Nothing to babysit.
Read the docsProcess · SDLC
The seven-stage pipeline with named specialists
One ticket walks all seven states in order. A transition dispatches the one routine for that stage — planning bundle, implementation, review. You can stand a new hire in front of the board on day one and they can read it.
Read the docsAudit
Every action, one query away
Every workspace, member, integration, pipeline, repo, clarification, invite, and agent action — captured. Query it with audit_search from your agent or the API, filtered by actor, action, and time. If a question can be answered by grep, it is answered here.
Read the docsThe specialists
Named agents. Versioned roles. Swappable executors.
A specialist is a role definition — "developer", "code reviewer", "validation bundle" — pinned to a stage. The executor (Cursor, Claude Code, Codex, Copilot) plugs in underneath. Swap executors tomorrow and the routine, the specialist, and the process stay unchanged. That separation is the whole product.
Pipeline owners
Platform
Intake / clarify
Keep going
Docs
Every surface, every flag
Orientation, Setup, Process, Inbox, Knowledge, Audit. The full reference.
Open
Quickstart
Your first hour with Ship
Eight operator steps. ~20 minutes start to finish.
Open
Case study
ElMundi UA
5,000 years of history, shipped by one operator and the loop.
Open
Pair with
Lighthouse — the memory
Durable memory for agents. The other half of the operating model.
Open
Closed beta
Open the console and walk the loop. Or read the book first.
We onboard a small cohort at a time. If you run a product line and want a delivery loop your team can read at a glance — start here.