What should I run first?

Install the Community CLI and run `shipmoor scan --changed` after your agent finishes. It is designed to be useful before CI, before PR review, and before any account or hosted setup.

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 free 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 for this change and whether any were removed or weakened to force a green. Code Review is advisory: your own coding agent walks the diff and raises the findings a careful reviewer would, and it never gates. Claim Check is the capstone: it freezes your intent and composes all of the above into one verdict on whether the change earned its claim. Scan is free in Community; the rest ship in Shipmoor IC.

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.

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. Shipmoor hosts no model and uploads no source. When Code Review or Claim Check needs a model, it is your own agent under your own account, and its output can only advise. The deterministic floor needs no model at all.

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?

Yes. Community gives you local scans, deterministic JSON, SARIF, and CI-friendly exit codes. Team adds managed CI gates, PR comments, shared baselines, and team policy. The CI gate runs the deterministic floor only: binary, reproducible, no model, and no secrets.

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?

No. The CLI runs where the code already lives and does not upload source. Team and Enterprise workflows export findings, hashes, severity, policy results, JSON, and SARIF while keeping source inside your environment. The Console is a control plane for auth, billing, and licensing; it never receives source.

Why would a user upgrade after trying the Community CLI?

Community proves the local habit. Individual developers upgrade to Shipmoor IC for Claim Check, Test Evidence, advisory AI code review, Agent Skills, and the agent harness across Claude, Codex, Cursor, and Aider. Teams upgrade to Team for managed CI gates, PR comments, shared baselines, and policy. Enterprise adds governance, audit logs, SSO, self-hosted runners, and data residency.

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.

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 a 30-day trial Start a 30-day trial Start Shipmoor IC Start Shipmoor IC

Local · no source upload
Always-free CLI
Checks agent claims against intent

Runs in the loop, wherever code is created

Codex

Claude Code

Cursor

VS Code

JetBrains

30 days of Shipmoor IC

Choose how you want to try Shipmoor.

Request beta access with no card, or start a free trial with a card at activation. We’ll email your invite URL and access code.

Beta tester No card

Help shape Shipmoor

Get 30 days of beta access with no card required. Use Shipmoor in your workflow and share what would make it better.

30 days · No card · Invite required

Free trial 30 days free

Start with full access

Get 30 days of Shipmoor IC. A payment card is collected when you activate your invitation.

30 days · Card at activation · Invite required

Free Community CLI

Try Shipmoor in your shell

Work with Shipmoor directly in your codebase. Scan agent-generated changes locally. Get findings with severity, an explanation, and next steps before you push.

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

Or read the docs

No login
Always free
No telemetry

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. No account, no telemetry, no source upload.

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 Community 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. No telemetry, no source upload. Shipmoor is neutral across every agent, so the verdict is never written by the tool that wrote the code.

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

Shipmoor IC adds Claim Check: it 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: Community CLI for the developer shell, Shipmoor IC for Claim Check and agent loops, Team for CI gates and PR signals, and Enterprise for governance and self-hosted boundaries.

Compare the path Compare the path

SHIPMOOR Verification Manifest

Local-first · no telemetry · no source upload

Entry M-01 · Community

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.

scan --changedJSON · SARIFexit codes 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 local. Upgrade when you need more control.

Free local scans for everyone. Full verification for individuals with Shipmoor IC. Team enforcement, governance, and self-hosted runners when you need them.

Community

Free local scans for agent-generated code.

Free / forever

Get the Shipmoor CLI Get the Shipmoor CLI

Shipmoor CLI, local-only
Changed, staged, diff, and patch input
Human, JSON, and SARIF output
Stable CI exit codes
No account, telemetry, or source upload

Shipmoor IC

For individual developers using AI tools every day.

$19 / month

or $190 / year, two months free

Start a 30-day trial Start a 30-day trial

Everything in Community
Claim Check: a verdict on whether the change did the job
Test Evidence: whether tests really passed and were not gutted
Advisory AI code review with your own agent
Agent Skills for AI coding tools
Agent harness for Claude, Codex, Cursor, and Aider
Advanced CLI and IDE extension features

Coming soon

Team

For teams that want PR gates, shared policy, and a feedback loop.

$29 / dev / month

Request early access Request early access

Everything in IC
Managed CI gates and PR comments
Shared baselines and team policy
False-positive feedback loop
Jira, Slack, and SARIF integrations

Coming soon

Enterprise

For organizations with governance, audit, and compliance needs.

Custom

Request early access Request early access

Everything in Team
Org admin console and policy
SSO (GitHub, WorkOS) and audit logs
Private or self-hosted runners
Data residency

Questions teams ask first FAQs

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

The verification layer for AI agent loops.