slopGrade
AI writes your code. slopGrade decides: it passes or it blocks.
A deterministic gate on every pull request. Slop and cross-tenant leaks never reach main — a required check, not a score, not a debate. It reads the diff on your own runner ; only a verdict ever leaves.
Install the gate with the engineer who ships it.
Bring
A repo where an agent opens PRs — GitHub, your CI, the branch that has to hold.
Block
We install the gate and watch it stop a real cross-tenant leak before merge.
Roll out
Advisory → blocking across your repos, hosted in Canada. Production.
83
Gate classes · 123 detectors
0 FP
Calibrated on 5,000+ real repos
0 egress
Code never leaves your runner
2 min
To install — keyless OIDC, one workflow
A gate, not another scanner.
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 — 83 classes of slop and security leaks, calibrated to zero false positives across 5,000+ real repos, decided on every pull request as a required check. Red disables the merge, green lets it through. Deterministic : the formula, never an LLM.
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. No code leaves your runner.
01 — Detect
One workflow snippet — `uses: slopgrade/[email protected]`, keyless OIDC, nothing to store. The PR opens, the gate reads the diff on your runner and classifies it against 83 classes of slop and tenant leaks.
02 — Block
One required check, pass or block — no score, no comment thread. Red → the branch ruleset disables the merge. A query with no org filter, a hardcoded key, an unpinned action stops here, not in prod.
03 — Verify
The agent fixes, re-pushes, the gate re-runs. Green → the PR is mergeable again. Start in advisory on every repo — it flags reds without blocking — then switch to blocking when you trust the gate.
Turnkey, calibrated, and the leak nobody else catches.
The moat isn't the mechanism — it's the curated rulepack and the class the alternatives miss.
Turnkey, not tunable
You turn it on ; you don't author or tune rules. One workflow snippet, protected in two minutes. CodeQL and Semgrep are engines you configure — this is the rulepack that ships calibrated.
Zero false positives
Every class is calibrated to 0 false positives on a 5,000+ repo corpus before each release. A gate that cries wolf gets turned off — this one earns the block.
The cross-tenant leak — #1 class
An org-scoped query with no org filter is a customer-data leak in prod, invisible to the eye and missed by CodeQL and human review. It is our flagship class, caught before merge.
Deterministic, sealed, turnkey.
Built to sit inline on the PR — and to be trusted with your code because it never takes it.
A required check
Pass or block, written as a status check GitHub enforces. Red → the branch ruleset disables the merge ; green → it's mergeable. Binary and defensible, not a findings list to triage.
0 egress · physical split
Extraction runs on your GitHub Actions runner ; only the verdict leaves. The classifier stays closed server-side, the code never travels — nothing to leak, nothing to trust.
Keyless OIDC · 2-min install
One workflow snippet, authenticated by OIDC — no token to store, no secret to rotate. Read-only on your diffs, writes only a check status.
Open-source client
The extraction client is open — audit every line, fork it. Ten critical classes (SQLi, XXE, secrets, broken crypto…) are free and open forever, advisory on all your repos.
Advisory → blocking
Start in advisory on every repo : it flags reds without stopping anything, so you watch what it catches on real PRs. Switch to blocking, repo by repo, when you trust the gate.
Deterministic — the formula, not an LLM
Same diff, same verdict, every run. No model to prompt, nothing to drift, nothing to hallucinate a finding — and we run it on slopGrade itself before it ships to you.
The leaks that ship as green PRs.
83 classes across six categories, each with the exact pattern it catches. A brand-new variant trips the same class — there is no signature list to keep updated.
Cross-tenant & access
A query with no org filter, a SECURITY DEFINER view that skips RLS, a request body bound straight to the model — every tenant's rows, or a privilege field, leaking in prod.
Injection — 42 classes
SQL, command, SSRF, XXE — user input concatenated into a query, reaching a shell, a server-side fetch to a metadata endpoint, an XML parser with entities on. The bulk of the catalog.
Hardcoded secrets
`sk_live_…` committed into source — a live key in git history forever. Caught in the diff before it's pushed, not after it's leaked.
Broken auth
A JWT accepted with the 'none' algorithm, CSRF turned off on a mutating route, a missing access-control check — the forgeable token and the open door.
Weak crypto — 14 classes
MD5 on a password, certificate verification disabled on an outbound call, a static or zero IV that encrypts the same plaintext identically.
Infra & supply-chain
A security group open to 0.0.0.0/0 on SSH, `FROM node:latest`, debug mode on in prod, a CI action pinned to a branch not a SHA, a typo-squatted dependency on a floating range.
Free advisory, then block when you trust it.
See every leak for free ; block the merge when you're ready. You pay for what you protect, never per head.
Advisory — free forever
The 10 critical classes flag reds on all your repos without blocking anything. Watch what it catches on your real PRs, audit the open-source client, fork it. No card.
Blocking — from $29/repo
83 classes + interprocedural taint + Go/.NET/Java breadth, calibrated to 0 FP. The branch ruleset disables merge on red. Tapers with volume — $8/repo at 50+, a dormant repo stays $0.
Sovereign rollout
0 egress by construction — the code never leaves your runner. For teams that want it rolled out across every repo, hosted in Canada under one contract, Maxor Digital delivers it.
Any team merging code an agent wrote.
AI agents open PRs faster than review can keep up. If a machine can push to your repo, you need a deterministic gate on the way to main — not another findings list.
One deterministic philosophy, across the suite.
slopGrade shares the Maxor posture : deterministic math over black-box models, an open, auditable client over trust-us, a verdict you can defend on every PR. It is the gate between an AI and your main branch — the same discipline that runs Heisen, MaxorConnect, TensorYard and HullSmith.
Explore the Maxor suiteAvailability
—
Status
Production
Deployment
GitHub CI · 0 egress · Open-source client
Owner
Maxor Digital · IP held by Maxor Global LLC
Put a gate between the AI and your main branch.
A G1 call is free. Bring a repo where an agent opens PRs — we install the gate, show it block a real cross-tenant leak, then walk the rollout. Advisory is free forever ; blocking from $29 per repo, hosted in Canada when you need it.
slopGrade, answered
slopGrade is a deterministic CI gate for AI-written code. On every GitHub pull request it decides pass or block — a required check, not a score — so slop and cross-tenant leaks never reach main. It reads the diff against 83 gate classes and 123 detectors, calibrated to zero false positives on 5,000+ real repos.
The leaks that ship as green pull requests, across six categories : cross-tenant and access (a query with no org filter — our flagship class), injection (SQL, command, SSRF, XXE — 42 classes), hardcoded secrets, broken auth, weak crypto, and infrastructure and supply-chain. It gates the code regardless of who wrote it — it is not an AI detector ; the failure it measures is the leak in the diff.
One workflow snippet — keyless OIDC, installed in two minutes. When a pull request opens, the gate reads the diff and writes a pass/block verdict as a required check ; red disables the merge, green lets it through. Start in advisory on every repo, where it flags reds without blocking, then switch to blocking, repo by repo, once you trust it.
No — 0 egress by construction. Extraction runs on your own GitHub Actions runner and only the verdict ever leaves ; the classifier stays closed server-side and the code never travels. The extraction client is open-source, so you can audit every line or fork it.
Yes. It is live and self-serve at slopgrade.ai. Ten critical classes (SQLi, XXE, secrets, broken crypto and more) are free and open-source forever, advisory on all your repos ; blocking starts at $29 per repo and tapers to $8 at fifty or more, with a dormant repo staying free. Maxor Digital builds and runs it, and handles the rollout for teams that want every repo gated, hosted in Canada under one contract.