Skip to content

Looks fine in review. Breaks in production.

Unslop checks every push against fixed rules and your team’s own rules before the code is merged. Processed in the EU.

Private beta. Sign-up is closed.

tools/config_loader.pyAnti-Slop Gatekeeper · failure · 1 critical, 3 warnings
return str(eval(expr))

Line 11: SEC-011 (eval/exec with expression), WARNING, deterministic

except Exception as e:return expr

Line 12: MAINT-002, WARNING, confirmed

config_dict[key] = eval_expression(re.compile(pattern).findall(value)[0])

Line 18: HAL-002, CRITICAL, confirmed

except FileNotFoundError:print(f"Error: The file {file_path} does not exist.")

Line 32: COND-001 (Silent Error Swallowing), WARNING, confirmed

HAL-002 Calling 'findall()' on a regex containing capture groups returns a list of tuples rather than Match objects. Passing this tuple to 'eval_expression', which invokes 'match.group(0)', raises an AttributeError at runtime.

Each bar is one word of the file from pull request #219 in our test repository: 51 new lines, 4 findings after 75 seconds. Real output, not staged. Job 06a2b52c · November 4, 2026

Every finding says where it came from.

67 rules are checked by code, not by a model. Everything else is reported by a model, and in the fast review a blind pass re-checks it before it becomes a finding.

DiffRules (code)Model
  • SEC-011deterministicPath: rules checked by code, no model.
  • MAINT-002confirmedPath: model, then blind re-check, confirmed.
  • HAL-002confirmedPath: model, then blind re-check, confirmed.
  • COND-001confirmedPath: model, then blind re-check, confirmed.
  • MAINT-007unverifiedPath: model, re-check uncertain, third pass skipped.
  • A claim by the model, refuted in the blind re-check. It does not arrive.

Blind re-check

HAL-002 · Line 18

Reasoning

The blind pass gets the rule, the location and the code. It does not get the reasoning of the first pass.

The first four findings come from pull request #219 (job 06a2b52c). MAINT-007 comes from pull request #17 (job f2c676ba): the re-check stayed uncertain, the third pass was skipped, and the comment says so: ⚠️ Downgraded to WARNING — this finding was flagged for Pro escalation, but the escalation was skipped (budget, API or time-limit degradation), so it could not be conclusively verified. The unnamed line stands for a refuted claim; refuted claims do not appear in the result, and the re-check stays only in the request's logs.

Not every finding gets the re-check: when time runs out it is skipped, and the deep review reports its own confidence. The review says so in each case.

Fast on every push. Deep when you ask.

The fast review runs on its own. You start the deep one when a pull request is worth it.

unslopai/test · Pull request #20 · checks
  • Anti-Slop Gatekeeperfailure · 1 critical slop finding · 16 s
  • Deep reviewAgentic review, takes minutes

On its own, on every push: reads the diff and the changed files, seconds, five minutes at most; a check run on the pull request and comments on the lines.

For teams. Processed in the EU.

One account for the team, your own rules, and the models run in the EU.

Read: 51 lines

Stored: 6 lines

In the result we store of this pull request’s code only what a finding quotes: 6 of 51 lines (pull request #219, job 06a2b52c). The finding itself is stored too, with its reasoning and suggested fix; the logs of the review steps can also refer to the code. What also stays: the repository index, built from signatures, interfaces and type definitions rather than implementation, and, with repository context switched on, the paths and size of the files read as repository context. For a scan from the CLI or the MCP server, the diff stays stored with the scan.
Your own rules
In plain language, for example “components never talk to the database directly”; checked on every push and marked as a team rule in the finding.
EU processing
The models run on the EU endpoint of Vertex AI and do not train on your code. From a pull request we store not the diff but findings with the quoted lines and logs of the review steps, plus one index per repository, built from signatures, interfaces and type definitions rather than implementation; details in the FAQ.
One team account
Members, roles and seats; the team shares its quota, and seats can be added any time.

Pull request, terminal, editor, coding agent: one review, four surfaces. The CLI, the VS Code extension and the MCP server are built and not published yet.

Frequently asked questions

Do you store our source code, or train on it?

We don’t train on it, and neither do Google or Anthropic: the Vertex AI terms exclude using customer prompts and responses to train Google’s models, and Anthropic’s terms do the same for the Claude model of the deep review. For a pull request we read the diff and the changed files from GitHub and store the findings with the quoted lines and logs of the review steps, not the diff and not the files. The deep review, which you start yourself, runs as an agent on a copy of the repository in Google Cloud Run in Frankfurt: we remove .env and key files first, replace detected secrets line by line, and delete the copy after the run. With repository context switched on, the review also reads a small rule-based selection of further files (manifests, database schema, a service’s start file), of which we keep only paths and size. A scan from the CLI or the MCP server uploads the diff and the full content of the changed files, plus that selection while repository context is on; the diff stays stored with the scan, the contents and the selection only until the review has loaded them, and the client refuses any diff in which it detects a secret before uploading. For connected repositories we store an index built from signatures, interfaces and type definitions, not from implementation logic; it is deleted 30 days after the repository is disconnected. GitHub tokens are encrypted at rest with AES-256-GCM, and every webhook is verified by its signature.

Which models run, and where?

The fast review runs on Google’s Gemini models, the deep review on a Claude model from Anthropic, both through Vertex AI on the EU multi-region endpoint, for which Google commits that processing stays inside the EU. The blind re-check runs on the same model as the first pass; its independence comes from what it is not shown, not from a different model family. The first pass and the re-check run at temperature 0; results still vary somewhat between runs.

Will this slow down our CI or block our merges?

It runs next to your CI, not inside it. The review runs as a GitHub check run with a hard limit of 300 seconds. Only critical findings fail the check; warnings conclude neutral and block no merge. Whether the check is required is your branch-protection setting.

Is this just another AI reviewer?

Partly, and we say which part. 67 rules are checked by code, and those findings never pass through a model. The rest is a model review whose findings a blind pass re-checks; when that pass is skipped, the review says so. A model finding can fail the check, which is why we bother.

Which languages are covered?

The model review reads TypeScript, JavaScript, Python, Go and PowerShell files. The rule check by code also covers Java, Rust, C and C++ and common config files. A pull request without a file in one of the five languages gets the rule check only; the check is then titled “Deterministic checks only”. When a pull request mixes both, the summary names the file types no model read.

What happens when a review fails?

The check is closed, not left hanging. A failed review concludes as a failure with the reason in the check, for example “Review timed out”. A review that does not start (no subscription, quota used up, repository deactivated) posts a completed check with “action required” and the reason. If you made the check required, your branch-protection overrides still apply.

Does our team have to learn another dashboard?

No. Findings appear as a check run and as review comments on the pull request. The CLI diffs your local changes against the merge-base, the VS Code extension shows findings in the editor; both are built and not published yet. The dashboard is for repositories, your rules, the team and billing.

Know what you merge.

Unslop is in private beta. Sign-up is closed for now.