Pre-launch checks for AI-built apps
Clear your app for launch.
Gantry runs 71 checks for the mistakes AI coding tools make — open databases, leaked keys, routes without a login check, runaway AI bills, privacy policies that don't match the code — and tells you in plain English what to fix first, with a prompt your agent can act on.
$ bunx @usegantry/cli check . Needs Bun 1.2+. Nothing to install; nothing leaves your machine.
- Checks
- 71
- Cold scan, 500 files
- 0.3 s
- Code uploaded
- 0 B
33 tags still on the vehicle. Pull them before launch:
| Project | acme/vulnerable-saas |
|---|---|
| Findings | 90 |
| Files | 32 · 12 routes · 5 tables |
| Ruleset | 2026.10.0 |
Both repos are fixtures in the Gantry source: the same SaaS stack, written badly and then fixed. This board is the scanner's real output, generated when this page was built.
The poll
Four stations. Each one calls GO, HOLD or NO-GO.
Can a stranger read, change or delete someone else's data, or spend your money?
- Missing or Permissive Row-Level Security (RLS)
- RLS Bypass via Postgres Views & SECURITY DEFINER RPCs
- ORM Insecure Direct Object Reference (IDOR)
- Publicly Writable or Enumerable Storage Buckets
Does personal data stay where your policy says it does?
- Unredacted PII in Vector Embedding Metadata
- PII Stored in an Unencrypted Local SQLite / Turso Embedded Replica
- Unredacted PII or Credentials in Application Logs
- Missing Right-to-Erasure Cascade (GDPR Art. 17)
Do your terms, privacy policy and licences match what the code actually does?
- AI-Hallucinated / "Slopsquatted" Dependency Detector
- Viral Copyleft License Conflict with Commercial EULA
- Missing Database-Bound Clickwrap Consent Trail
- Sub-Processor Drift (Code SDKs vs. Privacy Policy)
Will this run up a surprise bill or fall over on launch day?
- Cache Write on a Dynamic Key Without a TTL
- Blocking Call Inside an `async def` FastAPI Route (Event-Loop Freeze)
- Unbounded Goroutine / tokio::spawn Per Request
- context.Background() in a Go Handler That Has a Request Context
A blocker. It gets a remove-before-flight tag and stops CI in strict mode.
Worth fixing soon. Nothing here stops you launching.
Every check at this station passed on this commit.
The report
The five fixes that matter, in words you'd use.
gantry check leads with consequences, not rule IDs. Each fix comes with the exact file and line and a prompt written for Cursor or Claude Code, so your agent can make the change without you translating a security report.
Point it at a folder or a GitHub URL. Public repos need nothing; private ones use your existing gh login. Gantry downloads a snapshot, never runs your code and never installs your dependencies.
Not ready to launch yet: fix 33 issues marked "Fix before launch" first.
- Paste into your AI agent
Remove the literal from `env.OPENAI_API_KEY` in .claude/settings.json. Export OPENAI_API_KEY in your shell (or put it in the git-ignored `.claude/settings.local.json`; `git rm --cached` it if it's tracked) so the committed settings carry no secret.
Static analysis only: no code was run and nothing was probed. A clean result isn't a security guarantee.
Every check
71 rules, each with a real finding.
Open any rule to see what it caught in Gantry's own test fixtures and the prompt it hands your agent. 11 rules are compliance packs (HIPAA, PCI, legal privilege, EU AI Act, air-gapped builds) that run only when you ask for them.
Wire it in
Checks where the code gets written.
1 · Your agent
Claude Code, Cursor and other MCP clients can run the audit, sync legal docs and fire probes themselves.
{
"mcpServers": {
"gantry": { "command": "bunx", "args": ["@usegantry/mcp"] }
}
}2 · The stop hook
One command sets everything up. Existing issues are baselined, so the hook only blocks what the agent just introduced.
bunx @usegantry/cli init .
# writes .mcp.json, agent rules, gantry.config.json
# and a stop hook: the agent can't finish while it
# has added a new launch blocker3 · Every push
Findings land in GitHub code scanning; the badge and a signed certificate are a build artifact. Nothing is committed back.
# .github/workflows/gantry.yml
name: gantry
on: [push, pull_request]
jobs:
gantry:
permissions: { contents: read, id-token: write, security-events: write }
uses: askp-dev/usegantry/.github/workflows/scan.yml@v1
with: { strict: true } # fail the build on NO-GOLaunch clearance
A certificate anyone can check.
When the official GitHub workflow scans a commit, Gantry's signer checks GitHub's own identity token for that run and signs the result. The certificate link carries the result and the signature, and the verify page checks it in your browser. No account, no database.
What it proves: the official scan ran on commit X of repo Y and got this result. What it doesn't prove: that the code is safe. Certificates made on a laptop are labelled self-signed and never show as Verified.
✓ Verified · Gantry CI
| Project | acme/clean-saas |
|---|---|
| Commit | a8f3c21 |
| Ruleset | 2026.10.0 |
| Signed | Gantry CI · run 4242 |
Roast
Or just find out if it survives.
gantry roast makes a shareable card. It's built only from canned lines, so it never shows file names, routes or secrets: safe to post, even for someone else's public repo.
Roast a repoPrice
Free. MIT. Runs on your machine.
The scanner, the agent integration, the legal compiler, the live probes and certificates are all open source. Hosted extras may come later; the scanner stays MIT.