SlopGradeby Maxor Global LLC
Sign inStart the free 14-day trial
CI gate · AI-written code

AI writes your code.
slopGrade decides: it passes or it blocks.

A GitHub Action that blocks PRs adding a cross-tenant leak or PHP echo/print XSS before they reach main. Secrets and other injection findings are advisory. It judges only what the PR adds, so legacy code never turns it red.

Team: 14 days free, no card. Cross-tenant leaks and PHP echo/print XSS block free on public repos and 1 private repo; other findings report without blocking. 3 classes block on paid slots (125 detected), with Deep Scan on every Team PR.
fingerprint only on private reposkeyless OIDCinstalls in 2 min
PR #128acme/billing-apigate live
Pushed · the gate reads the diff
export async function listInvoices(orgId){- return db.from('invoices').select('*') }
!Blockedquery with no org filter · cross-tenant leak
fix pushed ↓
Re-pushed · the gate re-runs
export async function listInvoices(orgId){+ return db.from('invoices').select('*').eq('org_id', orgId) }
✓Passesorg_id filter added · ready to merge
Merge disabled while the slop check is red
Read-only on your diffs Writes a check, inline findings and SARIF On private repos, by default only a structural fingerprint is sent — `--print-payload` shows the bytesgate live
Preview the gate · public GitHub repo

Paste a public repo. See what the detectors find.

The same free detectors the GitHub Action runs on every pull request — SQL & command injection, XSS, SSRF, path traversal, XXE, unsafe deserialization, weak crypto, CORS and cross-tenant leaks — on any public GitHub repo, in about a second.

Try:

Public code only · nothing is stored · secrets are never reported · free-tier detectors (the paid Firewall runs the full catalog).

01The problem

Your team merges code no human wrote.

AI agents open PRs faster than review can keep up. Slop slips through, queries forget the org filter, a key leaks into a log. At volume, human review catches nothing — you need a deterministic gate, not an opinion.

02How it works

One loop: detect → block → verify

The gate lives in your GitHub Actions CI. It reads each PR's diff, decides, and writes its verdict as a required check. On a private repo only a fingerprint leaves your runner, unless you opt in to the deep scan (heisen-slop) on a paid repo. On a public repo the deep scan runs by default.

detectblockverify
01 · install

Copy the snippet

One GitHub Actions workflow pasted into your repo. Keyless OIDC — nothing to store.

- uses: maxor-tech/slopgrade-firewall@f18a953e15e84ff0f9e457da4a056ddea3548d46 # v0.13.6
02 · detect

The PR opens

The gate reads the diff on the runner and checks it for cross-tenant leaks and the security classes your plan covers.

$ node isolation-gate.mjs --print-payload
03 · block

Pass / block verdict

One required check, true or false. Red → merge is disabled by the branch ruleset.

slop · blocked → merge disabled
04 · verify

The fix goes green

The agent fixes, re-pushes, the gate re-runs. Green → the PR is mergeable again.

slop · pass → ready to merge
no riskStart in advisory on all your repos — it flags reds without blocking anything. Watch what it catches on your real PRs, then switch to blocking when you trust the gate.
03The firewall

125 classes detected. 5 layers. Blocking requires blind evidence.

The cross-tenant leak — a query with no org filter — is our flagship class. A class, or a specific shape within it, blocks only after public blind evidence shows at least 80% precision on at least 10 blind-labelled blocking rows. Until then, it reports findings without blocking. You turn on the rulepack; you don't write it.

Free · open-source · forever
Cross-tenant + PHP echo/print XSS
Cross-tenant leaks and PHP echo/print XSS block on every public repo and 1 private repo. For XSS, only unescaped PHP echo/print of request input ($_GET / $_POST / $_REQUEST / $_COOKIE) blocks. The 22 open-source detector packs still run on every repo; other findings report without blocking. Audit the client, fork it.
SQLiCmd injectionXSSSSRFXXEDeserializationPath traversalHardcoded secretsBroken cryptoCORS
Paid · detection and blocking
125 classes detected
3 classes block on paid slots: cross-tenant leaks, PHP echo/print XSS from unescaped request input, and HMAC/signature comparisons using == when a request can reach the comparison. Other XSS shapes (DOM sinks, Node reflected XSS, taint) and every other class report without blocking.
Rulepack coverageCross-tenant + PHP echo/print XSS block free · 3 blocking classes on paid slots
Cross-tenant + PHP echo/print XSS — free blocking125 classes detected · 3 blocking, paid
Classes by categorylive catalog
Injection6250%
Crypto2621%
Auth1512%
Infra1512%
Access54%
Supply-chain22%
L1

Tenant isolation

Every org-scoped query must carry its filter. The #1 cross-tenant leak in prod, caught before merge.

L2

Secrets & injection

Hardcoded keys, SQL/command/XXE/SSRF, deserialization — the bulk of the catalog.

L3

Crypto & auth

Weak algorithms, short keys, RSA padding, reflected CORS, missing access control.

L4

Deep scan

Cross-file dataflow (heisen-slop) across 6 languages by default on public repos, by opt-in on paid private repos — advisory by default, blocking only if you choose.

L5

Fingerprint by default

On a private repo, by default only a structural fingerprint — file paths, {file, line, kind} and the table and column names the cross-tenant check needs is sent — never file contents. The deep scan (heisen-slop), on by default on public repos and opt-in on private repos, sends at most 80 sink files, analysed in memory and dropped. Enterprise can run that engine on your network.

04The catalog

Every class, with the code it detects.

A sample of the 125 classes — grouped by category, each with the exact pattern it catches before it reaches main. Detection runs on your runner; this is what it looks for.

Access5
Cross-tenant · access-control
✗ db.from('invoices').select('*')
A query with no org filter — every tenant's rows leak in prod.
RLS · SECURITY DEFINER
✗ create view billing as select * … security definer
A definer view that skips row-level security.
Mass-assignment
✗ User.create(req.body) // is_admin passes through
Request body bound straight to the model — privilege fields slip in.
Injection62
SQL injection
✗ db.query('select * from u where id = ' + req.params.id)
User input concatenated into a SQL string.
Command / code
✗ exec('convert ' + req.query.file)
User input reaching a shell command.
SSRF
✗ fetch(req.query.url) // hits 169.254.169.254
A server fetch to a user-controlled URL — reaches the metadata endpoint.
XXE
✗ libxml.parseXml(body, { noent: true })
XML parsed with external entities enabled.
Auth15
JWT alg-none / bypass
✗ jwt.verify(t, key, { algorithms: ['none'] })
A token accepted with the 'none' algorithm — forgeable.
Hardcoded secrets
✗ const stripe = 'sk_live_4eC39Hq…'
A live key committed into source (and git history forever).
CSRF disabled
✗ app.use(csrf({ ignoreMethods: ['POST'] }))
CSRF protection turned off on a mutating route.
Crypto26
Weak crypto
✗ crypto.createHash('md5').update(password)
MD5 / SHA-1 where a password hash is required.
TLS-verify off
✗ new https.Agent({ rejectUnauthorized: false })
Certificate verification disabled on an outbound call.
Static / hardcoded IV
✗ createCipheriv('aes-256-cbc', key, ZERO_IV)
A reused / zero IV — the same plaintext encrypts identically.
Supply-chain2
CI/CD mutable pins
✗ uses: some/action@main # not a SHA
A CI action pinned to a branch, not a SHA — silently swappable.
Mutable deps · slopsquat
✗ "lodahs": "*" // typo'd name, floating range
A floating range on a typo-squatted package name.
Infra15
IaC open-ingress
✗ cidr_blocks = ["0.0.0.0/0"] # port 22
A security group open to 0.0.0.0/0 on SSH.
Docker unpinned
✗ FROM node:latest
A base image pinned to :latest — non-reproducible, it drifts.
Debug mode in production
✗ DEBUG = True
Debug mode left on in production.

See all 125 classes →

05Vs the alternatives

Not another scanner. A turnkey gate.

CodeQL and Semgrep are engines you configure and tune. Human review doesn't scale to agent-speed PRs. slopGrade is the curated rulepack you turn on — 125 classes detected, 3 blocking on paid slots after passing the public blind-evidence bar. All other classes report without blocking.

slopGrade
CodeQL
Semgrep
Human review
Setup
One workflow snippet · keyless OIDC · 2 min
Write your own queries
Author & tune rules
Hire & schedule reviewers
Cross-tenant leak (#1)
Curated & calibrated — flagship class
Write & tune the query
Author the rule
Invisible to the eye
False positives
Public blind evidence before blocking; advisory first. Historical replay before this bar: 59 of 52,089 ordinary open-source PRs blocked
Tune per repo
Depends on your rule set
Fatigue at volume
Verdict
Pass / block — a required check
SARIF findings list
Findings list
A comment thread
Your code leaves the runner
Private code: no, unless you opt in (paid). Public code: deep scan by default.
Runner-local
Cloud or local
n/a
Scales to agent-speed PRs
Deterministic, every PR
Yes, if maintained
Yes, if maintained
No
06The proof
125
gate classes
Derived from the live catalog — 6 categories, growing weekly.
3
classes block today
Historical replay, before blind-evidence gating: on 52,089 ordinary open-source pull requests, the gate blocked 59 (0.11 %). This does not measure today's blocking set. Now a class needs public blind evidence: at least 80% precision on at least 10 blind-labelled blocking rows. All other classes report without blocking.
0
lines of source stored
The hosted engine stores nothing: source is analysed in memory and dropped.
2 min
to install
Keyless OIDC, one workflow snippet, protects main.

Deterministic by design · open-source client, auditable · we run it on slopGrade itself before it ships to you.

07Pricing

Free advisory forever. Solo $49/mo for you, Team $299/mo for your team — both block the merge and prove the flaw.

One price per plan, never per head. Solo: 10 private repos, one person. Team: 50 private repos, unlimited users. Both block on 3 classes, and Deep Scan follows the value from the request to the sink. Agents, API keys and MCP clients never count as seats.

Compare plansSee every leak for free. Block the merge — and prove the path — when you're ready.
Free · advisory$0 / forever
Solo$49 / monthor $490 / year — 2 months freeFor one person
For a teamTeam$299 / monthor $2,990 / year — 2 months freeUnlimited users
Classes
Cross-tenant + PHP echo/print XSS block · 22 open-source packs run; other findings report only
3 block · 125 detected
3 block · 125 detected
Blocking
Public repos + 1 private
10 private repos included, then $4 / repo, up to 50
50 private repos included, then $4 / repo up to 100 and $3 beyond, no cap
Advisory
Every repo; open-source findings never block
Every repo
Every repo
Deep Scan (heisen-slop)
Not included
API 2,500 files / month
On every PR, not counted · API 5,000 files / month, then $10 per 1,000
People
Unlimited
1 person · agents and API keys never count
Unlimited — never per seat
Languages
JS/TS · Python · Go · .NET
+ Java
+ Java
Open-source client
✓auditable
✓auditable
✓auditable
Calibration
✓
✓before a class blocks
✓before a class blocks
Deep Scan · by heisen-slop, our flow engine

The gate recognizes the flaw. Deep Scan proves the path.

It follows a value from the request to the sink — through variables, calls and imported files — and reports only the flows it can prove, each step with its file:line.

Proven flows
source → sink, step by step, on every PR of your Team repos.
Library mode
public parameters as sources — candidates to triage, never a verdict.
Proof oracle
/api/verify: send the alert of any tool, get back a replayable proof or an honest abstain.
Deep Scan is advisory by default. You can make a new finding block the build (deep-scan-block) — on real CVE code its blocks are right at least 3 times in 4; on 52,089 ordinary open-source pull requests it blocked 245, 46 of them for a real flaw — so it stays off unless you choose it. « No flow proven » is not a guarantee of safety. On a private repo your source leaves the runner only if you turn Deep Scan on; on a public repo it is on by default.
In CI · Team reposevery PR · not counted
API + oracle · Solo2,500 files / month
API + oracle · Team5,000 files / month
Beyond, once you turn it onpaid plan + card · invoiced on the 1st$10 / 1,000 filescapped at $2,000 / month
Get a Deep Scan key
Enterprise — negotiated, annual contract: volume price past Team's curve, Deep Scan past 200,000 files / month, custom detector packs, SLA and no-retention DPA. SSO and an in-house deployment are scoped and dated in the contract.
Book a 30-min call
14 days free
No card on your first Solo or Team plan, once per account. Nothing is charged before you add one.
On day 14
Without a card the subscription pauses — repos, settings and history are kept — and resumes the moment you pay.
One leak caught
A single cross-tenant leak stopped before merge = years of subscription. The gate pays for itself once.
08FAQ

Straight answers.

QWhat is slopGrade?

A deterministic CI gate for AI-written code: on every GitHub pull request it decides pass or block before the code reaches main. No score, no debate.

QDoes my code leave my CI?

Not by default. The client reads your files on your GitHub Actions runner and sends only a structural fingerprint — file paths, {file, line, kind} and the table and column names the cross-tenant check needs, for classification. `--print-payload` shows the exact bytes. The exceptions are Deep Scan (heisen-slop) on a public repo, on by default, and the opt-in Deep Scan on a paid private repo: at most 80 sink files, analysed in memory and dropped, advisory unless you set deep-scan-block. A free private repo never sends source.

QHow much does it cost?

Advisory (scan without blocking) is free forever on all your repos, and blocking is free on public repos and one private repo. Team is $299 per month — 50 private repos included, Deep Scan on every PR, unlimited users — then $4 per repo up to 100 and $3 beyond. Enterprise is a negotiated contract.

QIs there a free trial?

Yes: Team is free for 14 days on your first Team plan, with no credit card. Without a card on day 14, the account pauses — repos, settings and history are kept — until you pay.

QWhat does the firewall detect?

Cross-tenant leaks and PHP echo/print XSS block on every public repo and 1 private repo. For XSS, only unescaped PHP echo/print of request input ($_GET / $_POST / $_REQUEST / $_COOKIE) blocks. The 22 open-source detector packs still run on every repo; other findings report without blocking. Paid slots detect 125 classes. 3 classes block on paid slots: cross-tenant leaks, PHP echo/print XSS from unescaped request input, and HMAC/signature comparisons using == when a request can reach the comparison. Other XSS shapes (DOM sinks, Node reflected XSS, taint) and every other class report without blocking. Blocking requires public blind evidence showing at least 80% precision on at least 10 blind-labelled blocking rows, measured per class or shape.

Put a gate between the AI and your main branch.

Create an account, paste the snippet, protect your first repo in two minutes. Team: 14 days free, no card.