Comparison
How Shipwright compares.
The AI coding-agent field has matured into recognizable tiers. We are not going to pretend the landscape is simple — or that Shipwright occupies a category no one else does. Here is the honest version: where each tool sits, what they are great at, and where Shipwright is genuinely different.
Market structure
The AI coding agent space has settled into three poles. Where you sit on this spectrum should drive which tool you reach for.
Individual Copilots
Cursor, GitHub Copilot
Autocomplete, inline suggestions, single-dev productivity. Excellent at what they do — not designed to coordinate a team's delivery pipeline.
Team AI Workflow Gap ← Shipwright
Shipwright Harness
Structured, multi-step delivery with a human review gate, shared task queue, policy controls, and audit trail. The gap between copilot UX and autonomous agents.
Autonomous Agents
Devin, OpenHands, Augment Code
Fire-and-forget agents that operate with minimal human involvement. Best when you trust the agent fully and want maximum autonomy.
Shipwright sits in the middle — team AI workflow — not because individual copilots are weak (they are excellent at developer productivity) and not because autonomous agents are wrong (they are right for the right teams), but because most engineering teams are somewhere in between: they want automation, but with visibility, controls, and a human in the loop on the decisions that matter.
The landscape
Commercial-tier agents in mid-2026 — the tools teams actually evaluate when choosing an AI delivery layer. MIT / own-it / self-hosted is table-stakes on the open-source side — every serious open-source tool runs on your infra, so it earns parity, not separation. The delivery-pipeline layer is already contested: OpenHands runs it today, Augment Code's Remote Agents pull from a background task queue and land review-ready PRs, and the commercial tier is moving fast.
| Tool | License | Models | Task Queue | Team Visibility | Policy Controls | Human Review Gate | Cron / Scheduling | Slack-Native Workflow | Tests-First Enforcement |
|---|---|---|---|---|---|---|---|---|---|
| Devin | Commercial | Proprietary | Yes | Dashboard | Basic | Optional | Yes | Partial | No |
| Cursor | Commercial | Agnostic (multi) | No | None | None | No | No | No | No |
| GitHub Copilot Agent | Commercial | GPT-4o / Claude | Issues-based | PR-level | Repo policies | PR review | Via Actions | No | No |
| OpenHands | MIT | Agnostic (100+) | Yes | Limited | Config-level | Optional | Yes | No | No |
| Augment Code | Commercial | Agnostic (Claude/GPT/Gemini) | Yes — Remote Agent queue | Slack + PR | Enterprise (SOC 2 / ISO 42001) | PR review | No | Yes — codebase Q&A | No |
| Shipwright Harness | MIT | Claude Code | Yes — shared, assignable | Slack + PR trail | Per-repo, per-skill | Yes — plan approval required | Yes — cron-native | Yes — first-class | Yes — enforced |
The pattern in this table: individual copilots (Cursor, GitHub Copilot Agent in simple mode) are optimized for single-developer productivity — no team queue, no visibility, no review gate needed. Autonomous agents (Devin, OpenHands, Augment Code) are optimized for fire-and-forget — high autonomy, PR-gated or optional review. Shipwright sits between: structured pipeline, shared queue, and a human review gate by default. That structure is the whole point.
What actually makes Shipwright different
Plan-first, human-gated
Specs become a reviewable task queue before a line of code is written, and a human approves the plan. It is structured autonomy with a checkpoint — not fire-and-forget.
Tests land with the code
Every task ships its tests in the same PR, written before the implementation (red-green-refactor is enforced). CI must be green before merge. No “add tests later.”
Claude-native by design
The planning prompts, review loops, and context system are tuned for one runtime instead of averaged across many. Claude-optimized, not lowest-common-denominator.
On "own-it": running on your own infra is necessary, not sufficient — a local agent can still read secrets and act on your behalf. Shipwright's answer is permission scoping, approval gates, and an auditable review trail, not "your code never leaves your machine" alone.
Run it yourself
Self-host it on your own infrastructure
Shipwright is MIT-licensed, with no managed service in the loop. The plugin runs inside Claude Code; the cloud agent — admin, metrics, and runner — deploys to Docker or to your own Kubernetes cluster with the bundled Helm chart. Your code and the agent that writes it both stay on infrastructure you control.
helm repo add shipwright https://app-vitals.github.io/shipwright
helm install shipwright shipwright/shipwrightOne chart packages the admin, metrics, and agent services (plus an optional PostgreSQL). Runs on Minikube, GKE, and EKS.
- MIT-licensed — fork it, audit every line, run it in your own cluster.
- No managed service between your repository and the agent.
- Bring your own Claude Code credentials — nothing routes through an App Vitals service.
Head to head
Shipwright vs Devin
Devin is the highest-profile autonomous coding agent — a managed commercial service with a strong benchmark track record. Choose Shipwright when you want the full pipeline, deploy stage included, on infrastructure you own and operate; choose Devin when a fully managed service with no infrastructure to run yourself is what you want.
Head to head
Shipwright vs OpenHands
OpenHands is the category leader in open-source autonomous agents — MIT, model-agnostic, deployable on your infra, ~78K stars, and it already runs a delivery pipeline (scheduled tasks, triggers, PR review, opening reviewable PRs). If you want maximum model flexibility and a mature ecosystem today, it is an excellent choice. Here is where the two genuinely differ:
Choose Shipwright when
- You have already chosen Claude Code and want a pipeline tuned for it, not averaged across providers.
- You want tests written first and landed with every change, gated by CI, by default.
- You want a plan a human approves before the agent builds — structured autonomy with a checkpoint.
Choose OpenHands (or the field) when
- You need BYOK / model-agnostic across many providers, including local models.
- You want the largest community and the most mature ecosystem available right now.
- You are not committed to a single runtime and want to keep that optionality.
Head to head
Shipwright vs Augment Code
Augment Code pairs a context engine built for very large codebases with "Remote Agents" — cloud workers that pull tasks from a queue, run in the background, and land review-ready PRs — plus a Slack app for codebase-aware Q&A. It is well-funded and enterprise-focused, with real autonomous-agent chops. Here is where the two differ:
Choose Shipwright when
- You want MIT / self-hosted on your own infra, not a managed SaaS with enterprise contracts.
- You want a human to approve the plan before code is written — not review after the fact on a PR the agent already opened.
- Tests-first and CI-green are enforced by the pipeline, not left to the agent's judgment.
- You have committed to Claude Code and want a pipeline tuned for it, not a router averaging across providers.
Choose Augment Code when
- Your codebase is very large and you want a purpose-built context engine across hundreds of thousands of files.
- You want a managed service with enterprise security certifications and no self-hosting overhead.
- Your team already lives in the IDE and Slack, and wants agent access woven into both.
- Model flexibility across providers matters more than depth on a single runtime.
Customizability — opinionated by default, malleable by design
Shipwright ships with an opinionated pipeline: plan, build, review, ship, with tests-first enforcement and a human approval gate. That pipeline is not locked in — every stage is customizable.
Swap skills
Each pipeline stage is a skill. You can replace the default planning skill with your own, add a pre-deploy gate, or swap the review skill for a custom policy check. Skills are plain markdown files — no special build step.
Disable default crons
The built-in review and patch loops ship disabled on new agents. Enable what you want; skip what you do not. Some teams run only the task queue and plan gate, and manage review manually. That is a valid configuration.
Add custom gates
Pre-check scripts can block a cron from firing based on any condition you define — CI status, PR state, time of day, external API call. The gate runs before the agent, so you control when automation is appropriate.
Every tool in the landscape above has converged on some form of this — Devin has Playbooks and CLI-beta Skills, Cursor has rules and hooks, Copilot Agent has custom .agent.md agents, Augment Code has Rules and CLI-only Subagents, and OpenHands has Skills and hooks in the open. The difference is where it lives: for the commercial tools, the deeper extensibility (subagents, hooks, plugins) sits in a separate CLI product, often beta, sometimes pulled without notice (Cursor removed Custom Modes in v2.1). Shipwright's skills, gates, and cron controls are first-class in the one product you actually run.
Honest note: Shipwright is not as easy to customize as rolling your own pipeline from scratch — if you want total control from day one, a bespoke setup is simpler. What Shipwright offers instead is a battle-tested pipeline you can start with immediately, and customize over time as you learn what your team actually needs. Some teams have disabled all the defaults and built their own workflow on top. You own the infrastructure either way.
The honest trade-off
Shipwright runs on Claude Code only. That is a deliberate bet, not an oversight: we think a pipeline built for one excellent runtime beats one hedged across a dozen. If model-agnosticism is a hard requirement, the field above is strong — use it. If you are building on Claude Code and want structure, tests, and a review gate around it, that is exactly what Shipwright is for.
We hold ourselves to the same honesty here: Claude Code is not a closed, locked-in dead end, and we do not pitch it that way. The case for Shipwright is Claude Code quality, not Claude Code exclusivity.
Try it
Install the plugin into Claude Code and run a task end to end. Free, MIT, runs on your own infra.
/plugin install shipwright@app-vitals/shipwright