GitHub
How it works

Start to end, in plain words.

AI assistants write code fast - too fast to eyeball everything they do. nimblegate is a checkpoint you run on your own server: every change your AI makes must pass through it before reaching your real code storage. This page is the whole product, one screen.

The three places

The whole product is one rule about who may talk to whom.

1 · The workshop

AI agent + developer

Where code gets written. nimblegate is not here - it never watches the AI think or type.

→git push
SSH, port 2222
2 · The checkpoint

nimblegate

A small server you run yourself. Opens every push, reads every changed file, applies your rules.

holds the only vault key
→clean pushes only
byte-for-byte, <1s
3 · The vault

GitHub · GitLab · Gitea

The official copy of your code. Only ever receives changes the checkpoint approved.

⟲ Rejected? The push is held, never stored. The reason goes back to the AI as a comment - it reads what failed, fixes its own code, pushes again. The loop closes itself.
The rule: the workshop only talks to the checkpoint, and only the checkpoint talks to the vault. The AI never holds a key to the vault - the checkpoint keeps the only credential.

The journey of one change

Seven steps - one of them is the entire product.

The AI writes code in the workshop. No gate involvement yet - nothing is slowed down.
The AI pushes. "Push" is git's word for "send my finished changes to storage." The address it pushes to is the checkpoint.
The checkpoint reads the code - here, and only here. The moment the push arrives, every changed file is read, line by line. Not while typing, not in a nightly scan - at the door, before anything is stored.
The rules ("frames") check the content. Each frame is one rule card recognising one specific mistake - see the cards below.
The decision: forward or hold. Clean pushes relay to the vault untouched in under a second. Findings are held with a written reason: which rule, which file, which line.
The fix loop (Auto-PR). Rejection reasons are posted where the AI can read them. It fixes itself and pushes again - no human needed in the loop.
Everything is recorded. Every push, decision, and reason lands in a permanent log and a live dashboard - one screen tells you what three agents did overnight.

What the rule cards catch

51 built-in frames plus your own rules. Exact patterns - same input, same answer, every time. That predictability is what lets the AI fix itself.

Leaked secretsPasswords, API keys, private keys written into code. Once a secret reaches storage it must be considered stolen.
History damageForce-pushes that rewrite the official history, attempts to skip the checks.
Destructive commandsScripts that would wipe protected folders, pipe unknown downloads into a shell.
Customer dataReal card numbers, bank accounts, IDs pasted into test files - verified mathematically, so random numbers don't trigger it.
Unapproved sourcesCode pulling software parts around your approved internal source.
Your own rulesCompany-specific patterns, added through a dashboard form with live preview. No programming, no rebuild.

The decision, both ways

Clean

Forwarded to the vault untouched - byte-for-byte identical, same author, same signature, in under a second.

On a good day nimblegate is invisible.

Finding

Held at the checkpoint. Never reaches the vault - the official history stays clean.

The pusher gets the exact reason; the AI usually fixes it on the next attempt.

The dial: two modes per repository

Enforce

Findings actually block the push. The guardrail.

Observe

Nothing is ever blocked - nimblegate silently records what it would have caught. A zero-disruption way to start: run it for a few weeks, then read the report and decide.

What it deliberately does not do

  • Doesn't write or change code - it checks and forwards; code arrives exactly as written.
  • Doesn't watch the AI think or type - it sees only what the AI tries to store.
  • Doesn't send anything anywhere - self-hosted, no telemetry; your code never touches anyone else's computers.
  • Doesn't replace human judgment - it removes the mechanical dangers so the review that remains can focus on "is this the right solution."
  • Doesn't catch what it has no rule for - a deterministic gate, not an all-seeing AI reviewer. That trade is deliberate.

See it running

The live demo is this whole page in motion - a real dashboard over sample data, nothing to install.

See Live Demo Install from GitHub