What should I run first?

Start free, install the Shipmoor CLI, authorize your device, and run `shipmoor scan --changed` after your agent finishes. Scan stays unlimited on Free and Pro.

How do Free monthly allowances count?

Free includes four independent monthly allowances: 5 Claim Checks, 5 Reviews, 5 Test Evidence runs, and 5 Blast Radius runs. A rerun counts as another invocation, and an agent invocation counts exactly like one typed by a user. A Claim Check that internally composes Review or Test Evidence consumes only one Claim Check invocation; those internal steps do not double-charge the other allowances.

What evidence does the verdict actually use?

Real signals your own toolchain already produces: deterministic scans, your build, your tests (including whether tests were quietly deleted or gutted), an advisory review, and checks bound to the task that must fail before the change and pass after it. Shipmoor composes them into one reproducible verdict on a deterministic floor. A model can advise on what the floor cannot bind, but it can only subtract trust, never grant it. That is the whole of “AI advises. Evidence decides.”

What's the difference between Scan, Test Evidence, Code Review, and Claim Check?

Scan is the unlimited deterministic layer: it catches structural agent failure modes like phantom imports, stub paths, and suspicious tests, and it can gate. Test Evidence answers whether your tests really passed. Review is advisory. Claim Check composes evidence into one verdict on whether the change earned its claim. Free includes 5 monthly invocations for each of Claim Check, Review, Test Evidence, and Blast Radius; Pro makes all four unlimited.

How is Shipmoor different from an AI PR reviewer?

A reviewer offers an opinion about your code, usually after the PR exists. Shipmoor returns an evidence-based verdict on whether the change did what you asked, before a human is pulled in. It is neutral: it does not write your code, so it has no reason to grade its own work green. No agent vendor can credibly attest against its own agent's claims; a cross-agent, deterministic, local verifier is the position that stays honest.

Claim Check freezes the intent behind a change into a contract of atomic, checkable obligations, binds each one to real evidence, and returns one verdict (READY, READY WITH GAPS, BLOCKED, or INCONCLUSIVE) with a replayable attestation. AI advises. Evidence decides: the verdict is carried by a deterministic floor over real evidence, never by a model. When an obligation has no check yet, Claim Check tells you exactly which check would prove it, so the next round can. It catches plausible-looking code that skipped the real side effect, implemented the wrong workflow, or solved a neighboring problem, and says so honestly where it has no evidence to decide.

Does a model ever block my merge?

No. A model can advise, and it can subtract trust by flagging a divergence it can point to, but a green light only ever rides the deterministic floor over real evidence. A machine that can hallucinate is structurally barred from being the gate. That is the credibility line the whole product is built on.

What languages does Shipmoor support?

Shipmoor verification is language agnostic. Claim Check, Test Evidence, and Code Review work with any programming language because they use the builds, tests, and checks in your own toolchain. The deterministic Scan currently adds native rules for Python, TypeScript, JavaScript, and Go.

How is Shipmoor different from a linter or SAST?

Linters catch syntax and style; SAST catches known security patterns. Both were built for human-written code. Shipmoor targets the failure distribution agents produce: phantom imports, hallucinated APIs, stub paths, swallowed errors, and tests that do not prove the requested side effect. Then it goes further and decides whether the whole change did what you asked, on evidence.

Can Shipmoor run in CI and comment on pull requests?

Free supports self-managed Scan in CI with deterministic JSON, SARIF, and stable exit codes. Managed CI gates, PR comments, shared baselines, and team policy are part of the coming-soon Team product; contact us to discuss them.

Does Shipmoor replace human review?

No. Shipmoor is the verification layer before review. It answers whether the change earned its claim and hands reviewers a cleaner, evidence-backed change to evaluate, so their judgment goes to the parts that actually need it.

Does Shipmoor need source code access?

The CLI reads code where it already lives so it can perform local verification, but source and diffs are not uploaded. The service receives only the account and command metadata needed for authentication, entitlements, allowances, and explicitly enabled features.

Why upgrade from Free to Pro?

Free keeps Scan, Agent Harness, and Agent Skills unlimited and provides 5 monthly invocations for each metered command. Pro is $19/month and makes Claim Check, Review, Test Evidence, and Blast Radius unlimited while adding the full IDE workflow, advanced configuration, and richer local history.

Is this the same Shipmoor as the boat mooring analysis software?

No. SHIPMOOR (shipmoor.com) is unrelated maritime engineering software for mooring analysis, built by HR Wallingford and Witherbys. This Shipmoor (shipmoor.dev) is a verification layer for AI-agent-written code. Different company, different industry, same name by coincidence.

Verification for the agent era

The verification layer for AI agent loops.

Q: My coding agent runs in the cloud. What actually stays local?

The verdict path. Scans, the deterministic floor, and gating decisions run on your machine or in your own CI. Source and diffs are not uploaded. Shipmoor contacts its service for authentication, entitlements, command allowances, and features you explicitly enable. When Review or Claim Check needs a model, it uses your own agent, and its output can only advise.

AI generates code at machine speed, but verification is still manual. Shipmoor composes evidence from your own builds, tests, in-depth code review, and deterministic scans into one reproducible verdict: did the change actually do what you asked? AI advises. Evidence decides.

Start free Start free See pricing See pricing

Free account · Local execution · No source upload
30 days of full Pro · no card
Useful Free plan after day 30

Runs in the loop, wherever code is created

Codex

Claude Code

Cursor

VS Code

JetBrains

30 days of full Pro

Start free. Keep shipping on Free.

Create a new personal account and get every Pro capability for 30 days. No card or payment method is needed. After 30 days, upgrade to Pro or continue automatically on Free.

New personal accounts No card

Full Pro first, useful Free after day 30

Pro is unlimited for the first 30 days. Free then includes 5 Claim Checks, 5 Reviews, 5 Test Evidence runs, and 5 Blast Radius runs each month, plus unlimited Scan, Agent Harness, and Agent Skills.

Start free

Free account · Local execution · No source upload

Shipmoor CLI

Try Shipmoor in your shell

Install one CLI for Free and Pro. Authenticate once, then run verification directly in your codebase.

Start free

curl -fsSL https://dl.shipmoor.dev/install.sh | bash

Read the CLI docs

Free account · Local execution · No source upload

Product demos

See it in action

One local-first loop, four moments. A deterministic scan catches structural defects. Claim Check returns a binding verdict backed by your build and tests. Code Review walks the diff using your own coding agent. The Agent Harness holds the agent at a gate until blockers clear. Runs locally. Your source code and diffs are not uploaded. Shipmoor only contacts the service for authentication, entitlements, command allowances, and features you explicitly enable.

Demo 01 · Shipmoor Claim Check

Your agent says done. Evidence decides.

Your coding agent says DONE. Claim Check demands proof. It breaks your intent into atomic obligations and binds them to real evidence from your own builds, tests, in-depth code review, and scans for AI defects. A deterministic floor returns one binding verdict, with no model in the decision loop. If it lacks proof, it blocks with the exact next action.

shipmoor claim-check --agent claude

Demo 02 · Shipmoor Scan

Scan the change before anyone reviews it

Run the Shipmoor CLI on an agent-generated diff and get a short list of high-confidence findings. Export JSON, an explanation, a patch, and SARIF from the same evidence.

shipmoor scan --changed

Demo 03 · Shipmoor Code Review

Review agent work with your own agent

Advisory code review right in your shell: a change summary, a file-by-file walkthrough, and precise suggestions. It always exits zero, so it guides the fix without ever blocking a merge.

shipmoor review --staged --agent cursor

Demo 04 · Shipmoor Agent Harness

Catch the defect inside the agent loop

The harness runs the scan on every edit and holds the agent at a Stop gate until blockers clear, feeding findings back as its next turn. The same loop on Claude, Codex, Cursor, and Aider.

shipmoor harness install claude

VS Code

JetBrains

Python

JavaScript

TypeScript

GitHub

Claude

Cursor

Codex

Aider

Works with your stack

Bring your tools and agents.
Shipmoor adds the verification layer.

Works with your IDEs, languages, and coding agents. Changes are checked locally before review, and source and diffs are not uploaded. Shipmoor contacts its service for authentication, entitlements, command allowances, and features you explicitly enable.

Works with your stack

Bring your tools and agents. Shipmoor adds the verification layer.

Inside your agent

Run Shipmoor where your code is written.

Agent Skills

Five skills your agent runs as it codes: review, fix, intent contract, guard, and PR preflight.

$shipmoor skills install claude

skill = behavior no source upload

Agent Harness

A loop that catches the defect before review: scan every edit, feed findings back, block what fails.

$shipmoor-harness install claude

edit → scan → fix CLI = source of truth

Plausible is not proven.

An agent says a change is done. The diff looks plausible. But did it actually do what you asked? Shipmoor answers with evidence, not opinion. It composes what your tools already produce: builds, tests, deterministic scans, and checks bound to your intent. One reproducible verdict, locally. A model never blocks your merge. Every gated change leaves a committed contract behind, so your repo gets easier to verify over time, not harder.

See how it works See how it works

Local-first, evidence-based

From agent output to a verdict you can merge on

Run Shipmoor when your agent says it's done: before CI, before a reviewer looks at it. You get a high-confidence verdict grounded in real evidence: what it verified, where it found a gap, and what it couldn't check yet.

Scan the generated change locally

Use shipmoor scan --changed, --staged, --diff main...HEAD, or --patch agent.patch to catch structural agent failure modes before anyone wastes time reviewing them.
Decide whether the change did the job

Claim Check freezes your intent, binds each obligation to real evidence, and returns one verdict on whether the change earned its claim. A deterministic floor decides; a model only advises.
Route the fix, then merge with proof

When the verdict blocks, Shipmoor provides the exact next action to close the gap. The agent or developer fixes it, reruns, and a replayable attestation travels with the merge.

shipmoor scan ./src skill v0.4

code-agent host · model 4.7

Triage — 5 files · weighted scoring

file

score

status

signals

features.py

0.00

scanning

6× phantom_import · 1× clone_cluster

db.py

0.00

scanning

1× phantom_import (asyncpg)

filters.py

0.00

scanning

—

targets.py

0.00

scanning

docstring_inflation 8.0 (module)

__init__.py

0.00

scanning

—

weighted_deficit_score = 0.00 → CRITICAL_DEFICIT

Deep-Dive — separating noise from defects

features.py · docstring_inflation × 6 symbols

_build_target_cte · features.py:42

10 / 4

Trim

build_segment_dataset · features.py:128

11 / 3

Keep

targets.py · module-level

8.0

Flag

Action Plan — safe patches + decisions

✓ patch _build_target_cte docstring · features.py 10→ 5 lines

✓ patch _load_sql docstring · features.py 6→ 3 lines

∙ add orchestrator / helpers split note · features.py comment

? decide targets.pyKeepTrimDelete awaiting

0 patches proposed · 0 decision pending · 0 destructive ops Run plan

Verification Manifest

Built for the moment before merge.

Shipmoor unifies local AI code checks into one verification layer. Free keeps Scan, Agent Harness, and Agent Skills unlimited and includes monthly allowances for Claim Check, Review, Test Evidence, and Blast Radius. Pro makes the full individual workflow unlimited. Team and Enterprise are coming soon; contact us to discuss them.

Compare the path Compare the path

SHIPMOOR Verification Manifest

Free account · Local execution · No source upload

Entry M-01 · Free

Catch agent defects while you still have the shell

VERIFIED M-01

Run Shipmoor after your agent finishes and before you open a PR. Get a short list of high-confidence risks with the context to repair them.

~/app — shipmoor exit 1

$ shipmoor scan --changed

scanning 7 changed files · python, typescript

Critical Hallucinated API core/aether.ts:42 Calls queue.flushPending() — no such method exists on the symbol.

High Phantom import core/aether.ts:3 Imports fast-retry, missing from manifest and lockfile.

High Stub path api/checkout.py:88 Returns success while the real persistence side effect is missing.

5 findings · 1 critical, 2 high, 2 medium — JSON, explain, patch and SARIF from the same evidence.

unlimitedscan --changedJSON · SARIF evidence retained · SARIF ready

Decide on evidence, not an opinion.

Given a change and its intent, Shipmoor composes your build, tests, scans, and bound checks into one reproducible verdict. If it can't check it, it says so.

Neutral across every agent.

Shipmoor doesn't write your code, so it holds the code honest. One verdict across Codex, Claude, Cursor, and Aider, not a grade an agent gives its own work.

Verifiability that compounds.

Every gated change leaves a committed contract and its checks in the repo. The next change starts already verifiable. Governance keeps it inside your boundary, with policy, audit, and self-hosted runners.

Evidence-based verdicts

Neutral, cross-agent

Local-first, no source upload

A model never blocks the merge

Start with full Pro. Keep a useful Free workflow.

Each newly created personal account gets 30 days of full Pro with no card or payment method. Then continue on Free or choose unlimited Pro for $19/month.

Free

Authenticated Free includes independent monthly allowances plus unlimited local foundations.

$0 / month

Start free Start free

Claim Check: 5/month
Review: 5/month
Test Evidence: 5/month
Blast Radius: 5/month
Unlimited Scan, Agent Harness, and Agent Skills
Free account · Local execution · No source upload

30 days free

Pro

Unlimited individual verification for developers using AI tools every day.

$19 / month

or $190 / year, two months free

Start free Start free

Full Pro for the first 30 days, no card
Unlimited Claim Check, Review, Test Evidence, and Blast Radius
Unlimited Scan, Agent Harness, and Agent Skills
Advanced verification configuration and local history
Full IDE workflow

Coming soon

Team

Managed CI, PR checks, and shared policy. Coming soon; contact us.

Contact

Contact sales Contact sales

Coming soon
Managed CI gates and PR checks
Shared policy, baselines, and evidence

Coming soon

Enterprise

Governance and enterprise identity. Coming soon; contact us.

Contact

Contact sales Contact sales

Coming soon
Selected identity, audit, and policy controls
Private execution options

Questions teams ask first FAQs

Short answers for developers, security, platform, and engineering leaders.

The verification layer for AI agent loops.