AgenticCLI
▮ shipguardis the security scanner your coding agent runs before every commit.$ npm i -g @agenticcli/shipguard

▮ ShipGuard by AgenticCLI · v0.10.0 · live on npm

The security scanner your coding agent runs before every commit.

Same code, same answer.

On your machine. Flat price, no seats. For SaaS founders shipping with Claude Code, Codex and Cursor.

One command scans the code Claude Code, Cursor and Codex wrote for the mistakes they make most — hardcoded secrets, broken auth, unverified payment webhooks, destructive migrations, debug config in prod.

$npx @agenticcli/shipguard scan
view on GitHub →view on npm →

✓ local scans free and unlimited✓ no account, runs on your machine✓ works with Claude Code, Cursor, Codex CLI

shipguard scan --changed --strict

Claude Code wrote this. ShipGuard caught it.

Runs alongside every agent and terminal.

Claude Code, Codex, Cursor — or any CLI, hook or CI. It reads exit codes natively, so your agent acts on the result.

ClaudeClaude
CodexCodex
CursorCursor

What makes it work

What makes a check work inside an agent loop — and why each property is load-bearing.

agent-native

JSON + exit codes. That's the API.

Your agent scans, reads the JSON recommendation field, applies each fix, and re-scans until it comes back clean. No dashboard to open. Your agent gets an exit code and JSON, and a report saves to .shipguard/.

$ shipguard scan --json
{"recommendation":"DO_NOT_SHIP","findings":[...]}
> agent fixes 2 findings
$ shipguard scan --json
{"recommendation":"SAFE_TO_SHIP"}

deterministic

Not an LLM. A rule engine.

Same code → same score → same exit code. Every time, on every machine. An LLM gives three different answers to the same question — ShipGuard gives one, and your agent can trust it enough to branch on it without asking a human.

# LLM review
"mostly safe"
"CRITICAL found"
"no issues"
# ShipGuard
78/100 · exit 1
78/100 · exit 1
78/100 · exit 1

local-first

Code never leaves the machine.

Free scans need no account and run on your machine. Cloud scans (any signed-in plan) connect once to download rule bundles via an authenticated edge gateway, then scan locally. Either way, no code, file paths, or file contents are ever transmitted. Rules come down. Code never goes up. Published builds (0.10.0 and later) send three small pseudonymous usage pings (after each scan, on first run, and after shipguard login) with no code, file contents, paths, repo names or secrets. Opt out of all three with SHIPGUARD_TELEMETRY=0 or DO_NOT_TRACK=1 or shipguard telemetry disable.

# free: code stays local
✓ code ✗ never ↑
# pro: rules downloaded, code stays
✓ rules ↓ code ✗ never ↑

framework-aware

Framework-aware rules, not one generic pattern.

ShipGuard's rules are tuned to Next.js App Router routes, Supabase RLS migrations, Stripe webhook handlers, and Firebase security rules — regex and string matching that knows route.ts in app/api/ is a public endpoint, not just a file with a string in it.

# knows Next.js route structure
CRITICAL auth:api-route-unguarded
app/api/admin/route.ts:1
→ public POST with no auth middleware
Fix: add auth guard or move to protected route

one command

Install and scan in one command.

No config files. No account. No setup wizard. One npx command and ShipGuard scans your project — locally, privately.

$ npx @agenticcli/shipguard scan
ShipGuard v0.10.0 — scanning 14 files
CRITICAL secrets:hardcoded-api-key
HIGH auth:admin-unprotected
Risk 72/100 · DO NOT SHIP

/loop

The observe step in every agent loop.

Every coding agent runs a loop: reason → act → observe → repeat. ShipGuard is the observe step — the deterministic checkpoint between "the agent wrote code" and "the code ships." It returns structured findings the agent can reason about and act on in the next iteration, closing the loop without a human in the middle.

# the agentic loop
reason → "add stripe checkout"
act → write code
observe → shipguard scan --json
reason → "fix 2 findings"
act → apply fixes
observe → shipguard scan --json → recommendation: SAFE_TO_SHIP ✓

hooks

A hard gate, not a polite request.

A CLAUDE.md instruction is a hope. A hook runs every time. Wire ShipGuard as a PreToolUse hook or a pre-push git hook and it fires deterministically at the boundary between "agent wants to push" and "code leaves your machine." Exit 1 blocks (with --strict). The agent doesn't get a vote.

# .claude/settings.json
PreToolUse → "Bash" → git push
→ run shipguard scan --strict
→ exit 1 = BLOCKED
# or just a git hook
.husky/pre-push
→ shipguard scan --strict
→ exit 0 = push proceeds

/goal

The stop condition agents actually trust.

Goal-based loops need an objective stop condition — not "does this look safe?" but a binary yes/no the agent can check deterministically. Passed with --strict, ShipGuard's exit code is that condition: exit 0 means no blocking findings remain. The agent's goal becomes: "get to exit 0." It can iterate autonomously — scan, fix, re-scan — with a clear, machine-verifiable definition of done.

# agent /goal: "ship clean"
$ shipguard scan --strict → exit 1
> not done. fixing...
$ shipguard scan --strict → exit 1
> still not done. fixing...
$ shipguard scan --strict → exit 0
> goal met. deploying.

Set up in Claude Code · Set up in Codex · Set up in Cursor

The security harness

Agents ship code faster than any human review can keep up. ShipGuard wraps the agent loop in a deterministic security check — so the mistakes it checks for are caught before they ship.

without a harness

no gate
dev in ~/checkout on ⎇ main ❯ git push && deploy
✓ deployed
! api key shipped to prod

with ShipGuard

shipguard gate
dev in ~/checkout on ⎇ main ❯ git push && deploy
CRITICAL secrets:hardcoded-api-key
Risk Score: 81/100 HIGH RISK
Status: BLOCKED — deploy halted

Five checks that matter

The five places AI agents actually break production — framework-aware regex and string matching, not one generic rule for every stack.

Secrets

Hardcoded API keys, tokens and credentials — before they reach your git history.

Auth

Unprotected admin routes, missing guards and broken session checks.

Payments

Unverified webhooks and missing signature checks on Stripe & friends.

Database

SQL injection, unsafe queries and destructive or exposed migrations.

Deployment

Debug flags, source maps and dev config shipped to production.

ShipGuard Pro

The free local check catches the obvious. Cloud scans go deeper — always-current detection rules, deep stack coverage, and cloud-delivered updates your agent gets automatically.

free — catches the common, high-severity mistakes agents make most: hardcoded secrets, unverified webhooks, unguarded routes

shipguard scan
secrets:hardcoded-api-key — src/lib/stripe.ts:4
payments:webhook-unverified — src/app/api/stripe/route.ts:8
2 findings · free rules

pro — catches the complex workflows, framework-specific patterns & more

shipguard scan --pro
secrets:hardcoded-api-key
payments:webhook-unverified
auth:supabase-rls-disabled
auth:firebase-open-read
deploy:cors-wildcard
db:migration-destructive
6 findings · full corpus

always-current

live threat-intel corpus

Cloud-delivered rule bundles — updated continuously without a CLI upgrade. Cloud rules are updated as new patterns are added; the rules bundled in the CLI update when you upgrade the CLI.

deep stack coverage

web · database · auth · secrets · supply chain

Rules that understand your tech stack — web frameworks, database ORMs and migrations, authentication providers, secret patterns, and supply chain dependencies. Cloud scans go deeper than the bundled rules into stack-specific failure modes that basic pattern matching can't reach.

shipguard.policy.yml

custom policy files

Define which findings block, which warn, and which paths to ignore — per project. Your policy travels with your repo and your agent respects it automatically.

free scanruns locally
1$ shipguard scan --strict
2bundled rules loaded
basic corpus · lagged
3scan runs locally
5 modules · local
4verdict → exit 0 / exit 1
pro scanrules ↓ · code never ↑
1$ shipguard scan --strict
2CLI generates a signed authentication token
auth local · token sent to edge
3edge gateway verifies
body cap → verify → rate limit
4convex → live rule bundle
always-current · credits deducted
5scan runs locally
full corpus in memory · safe regex engine
6verdict → exit 0 / exit 1

Simple, honest pricing.

Local scans are free and unlimited, forever. Paid tiers meter cloud scans. No per-seat pricing.

freeavailable now

$0 forever

Unlimited local scans on every push — for every team and agent.

  • Unlimited local scans
  • 5 cloud scans / mo
  • All 5 check categories
  • Deterministic exit codes
  • --strict CI gate
  • --json for CI & agents
  • Community support

A cloud scan runs your rules on our servers. Local scans are always free and unlimited.

Start free
Plusavailable now

$19 /mo

Billed monthly · cancel anytime

For the team that wants the full rule corpus in the cloud, month-to-month.

  • Everything in Free
  • 10 cloud scans / mo
  • Full corpus access
  • Month-to-month

A cloud scan runs your rules on our servers. Local scans are always free and unlimited.

Get ShipGuard Plus

Cancel anytime from your account. Your plan runs to the end of the paid period.

promost popular

$29 /mo

The full gate at volume — 100 cloud scans a month against the current rule corpus, for shipping in earnest.

  • Everything in Plus
  • 100 cloud scans / mo
  • Full current rule corpus on every cloud scan
  • Agent-payable credits & shared credit pool
  • Email support

A cloud scan runs your rules on our servers. Local scans are always free and unlimited.

Get ShipGuard Pro

Cancel anytime from your account. Your plan runs to the end of the paid period.

Prices in USD, plus applicable taxes.

FAQ

Does my code ever leave my machine?
Never. Every scan runs locally in your terminal — no code, file contents, or file paths are transmitted. Cloud scans fetch rule signatures only.
What's the difference between local and cloud scans?
Local scans are unlimited and free — the CLI runs checks as pure local functions using the bundled rules. Cloud scans run against the always-current full rule corpus over your authenticated session.
Does ShipGuard block my deploy?
Only if you opt in with the --strict flag. Without --strict, ShipGuard reports findings but exits 0.
How is this different from Snyk or Semgrep?
Those are security platforms for teams with a security engineer. ShipGuard is a local security scanner your coding agent runs before every commit: free local scans, focused on the mistakes AI agents make.
Can my agent run it automatically?
Yes — that's the design. --json emits machine-readable output, --strict turns the exit code into an autonomous gate, and it reads from any hook or CI step.

ShipGuard Pro is live.

More cloud scans against the current rule corpus — the full gate, ready now.

────────[ ▮ gate ]────────

Don't ship the next one.

Free, local, no account. Catches the security mistakes your agent ships, before deploy.

$ npx @agenticcli/shipguard scan