For Claude Code, Codex, Cursor and any MCP agent · Python today, TypeScript next

Your agent's code runs. LeanGate stops the code that doesn't belong.

Coding agents rewrite helpers your repo already has, drop timeouts, and do the unsafe thing a prompt asks for, then report the task done. LeanGate checks every change against your whole codebase, tells the agent what's wrong right after each edit, and won't let it finish while a blocking issue is open.

Tested on repos it had never seen

Claude Code, the same tasks with and without LeanGate, on PostHog, Dagster, frappe, JumpServer and addons-server. Each task five times; a separate model reviewed every result blind.

190

times the agent wrote the unsafe code a prompt pushed for (f-string SQL, eval(), verify=False, shell=True, a live key) and reported the task done.

Of 25 runs. With LeanGate it fixed the code or stopped and asked.

40%64%

of the time it used the helper the repo already has instead of writing its own.

25 runs each, five reuse tasks.

18 of 19

reused the helper once LeanGate had learned the repo, in 5 turns instead of 8.

Same tasks with LeanGate's memory wiped: 14 of 19.

The first LeanGate run let 4 unsafe changes through, all one gap (a PagerDuty routing key the secret check didn't recognise). It was fixed and the 0 is from the run after. Small samples: five runs per task.

Three checkpoints in the agent's loop

Hooks and an MCP server, so it works inside the agent you already use. Static checks run locally in milliseconds; Jev and NVIDIA Nemotron on Nebius Token Factory confirm the ones that need judgment.

Before it writes

The repo's own helpers

The helpers your repo routes HTTP, subprocesses and dates through, and the ones earlier changes used for tasks like this one, go into the agent's context with the task.

After every edit

What's wrong, right away

Reimplemented helpers, invented imports, missing timeouts, swallowed errors, injection, secrets: reported on the lines it just changed, before it builds on them.

When it tries to finish

The gate

It can't call the task done while a blocking issue is open. It can dismiss a wrong bloat finding; only a person can waive a security one.

Every run

It learns your repo

Which helpers do which jobs, how your endpoints check permissions, which rules are always right here. Per repo, nothing shared between repos.

Your code stays on your machine

The dashboard shows only repos your own LeanGate reported from, to you. Here's exactly what it receives.

Sent to the dashboard

Each run's findings: rule, file path in the repo, line, message, severity, the decision.
Timing and LeanGate's own model cost per run.
What LeanGate learned: helper names, rule records.
The repo's name, from its git remote.

Never sent to the dashboard

Source code: the snippets LeanGate shows you locally are dropped, and code quoted in a message is blanked out. Messages can still name a function or variable.
Your machine's file paths.
Repos with no git remote, or anything when sync is off (LEANGATE_CLOUD=off).
Your GitHub repos or code: sign-in only reads your public profile.

And the models?

To judge a finding, LeanGate on your machine sends the relevant snippet to Jev (OpenRouter) and Nemotron (Nebius Token Factory), with your own API keys. That doesn't pass through this site.
Export everything held for you, or delete it all, from your account page at any time.

Get started

LeanGate checks Python codebases today (it runs on Python 3.11+). Changed files in other languages are listed as not checked; TypeScript and JavaScript support is next.

1. Install LeanGate in your agent

# Claude Code (needs uv): the MCP server and all four hooks
/plugin marketplace add lambdabypi/leangate
/plugin install leangate@leangate

# Any other agent
pip install "leangate[providers]"
leangate hooks --write --repo .

2. Sign in here, make an API key on your account page, and connect this machine

leangate login --url https://YOUR-SITE --key <your key>

3. Work as usual: every run shows up on your dashboard as it finishes