Proof,
not guesses.
Follow the data.
Proof is the only security signal that survives $0, air-gap, and every re-run. Everything else guesses — regex from patterns, LLM reviewers from vibes (and they charge per PR and ship your code out). The Heisen engine proves each finding with deterministic dataflow taint analysis — running in your infra at $0 — and escalates only the genuinely ambiguous band to a 55M classifier we host. A block is a proven path from attacker input to a dangerous sink — never a pattern that happened to match.
A dataflow engine, not a pattern scanner.
The engine reads your code the way an interpreter would: it tracks every value from where it enters — a request parameter, a form field, a CLI argument — to where it lands: a shell, a query, a template, a deserializer. It raises a finding only when it can prove the path, and clears code only when it can prove the value is a constant. Everything it cannot prove escalates to our hosted 55M classifier — the deterministic tier itself runs in your infra at $0.
12 proven classes across 5 languages.
Every ✓ below is a live dataflow detector — a finding is a proven path from a request source to a dangerous sink. This is what the engine detects today.
✓ = a live dataflow detector for that language. A blank cell is on the roadmap, not shipped — we never mark a class we can't prove.
Prove → escalate → decide. Only the ambiguous minority leaves.
Deterministic taint analysis
The engine interprets each file abstractly and tracks taint from every source to every sink. A proven path is a BLOCK (p = 0.94); a value proven constant is CLEAN (p = 0.02). $0, auditable, and identical on every run.
Only the ambiguous band
When a dangerous sink meets a request source but no path can be proven, that ambiguous minority escalates to a 55M classifier we host. Only those cases ever leave your infra — the deterministic majority is decided locally at $0.
A verdict you can audit
The evidence carries the sink and the flow — never your source code. Run the deterministic engine self-hosted and air-gapped in your infra; only the ambiguous escalate band reaches our hosted 55M.
The axis the incumbents can't follow.
vs. regex scanners
A regex fires on text that looks dangerous. The engine fires on data that provably flows to a sink — so a safe parameterized query with the same keywords stays clean.
vs. LLM reviewers
An LLM gives a different answer on re-run, costs money per PR, and ships your code to a third party. The deterministic engine is 100% consistent, $0, and self-hostable — only the genuinely ambiguous minority reaches our hosted classifier.
vs. cloud SaaS
Every cloud scanner copies your repo out. The engine runs entirely in your runner or on-prem — air-gap proven — for the regulated code (FedRAMP, HIPAA, ITAR) that gets no cloud AI tool today.
Every number here comes from a run.
Every figure is the deterministic tier on public benchmarks (OWASP + a 1,034-case corpus); held-out precision is lower and never hidden — see the roadmap.
The maximum scope we're building toward.
What ships next — labeled honestly, because we never advertise a detector we can't prove today.
Precision is never traded for recall. Recall comes from adding proven layers, never from loosening one.
Straight answers.
Is it really $0?
Yes. The engine runs on your own runner — public repos are free via keyless OIDC — or self-hosted on-prem, with no per-scan cost and no model call on the blocking path. Private repos are gated through the hosted SlopGrade Firewall.
Does my code leave my infrastructure?
Never, on the deterministic tier — which decides the majority. It runs entirely in your runner or on-prem, air-gapped (proven x86 + ARM); only a verdict leaves. The genuinely ambiguous minority escalates to our hosted 55M classifier — turn escalation off for a fully air-gapped, deterministic-only deployment where that band goes to human review instead.
How is this different from Snyk, Semgrep or CodeQL?
They pattern-match and can give a different answer on re-run. The engine proves each finding by dataflow: 100% consistent, $0 at the margin, and self-hostable air-gapped. It only blocks a proven path and only clears a proven constant — so alert fatigue and false greens never creep in.
What about classes or cross-file cases it doesn't prove yet?
The hosted SlopGrade Firewall flags a broader 124-class catalog with server-side cross-file analysis. The engine is the subset it can prove by deterministic single-file dataflow — the part that runs air-gapped at $0. We never mark a class we can't prove; the roadmap grows the proven set toward the full catalog.
Put proof in your pipeline.
Run the engine on every PR — deterministic, $0, self-hostable and air-gappable.
Air-gapped or regulated? Talk to us about the self-hosted engine →