Check verifies an AI's commands before they run.

Every command an AI runs rests on guesses: this program exists, this file, this folder, this branch, this package. The AI can't see your machine, and the machine only answers after the command has run. Check sits in between: before anything runs, it asks your own machine about every guess, and if one is false the command is stopped, with a plain reason. File writes are checked too.

Install Check Pricing

Works with AI coding agents, on Windows or Linux. Node 18 or newer. Which agents, and what's checked in each: the guide.

It adds Check's hooks to each AI coding agent it finds on your machine (keeping your own hooks) and a folder at ~/.check with the hook script. Nothing goes into your project. From then on, every command and file write passes through Check before it runs, and your machine answers wherever it can.

1. Get your key at the console (100 free blocks). 2. No Node.js? Install it from nodejs.org. 3. Run this line in a terminal, yourself, not through your AI, and paste your key when it asks. 4. Restart your AI agent. Step by step: the guide.

Windows (PowerShell) or Linux

npx @golproductions/check@latest --install
Windows or Linux: macOS isn't tested yet, so it won't install there. Your GOL API Key comes from the console: 100 free blocks, then a prepaid balance on the same key. You only pay when Check stops something. Check keeps itself current: the Check client updates in the background, at most once an hour, and only to a version signed by GOLProductions.
01

How it works.

Three steps, every command and every file write.

01The AI writes a command.
Or a file. Before it runs, Check sees it.
02Your machine answers.
Does this program exist? Is this package real? Is this branch actually there?Your own shell, git and parsers answer. Not a model, not us.
03Stopped, with the reason.
If not, the command never runs and the AI is told why. It tries again with something that works.

A real catch.

From our own key, 5 October 2026. Claude was cleaning up after a job on this website. Its command used pkill, a standard Linux tool it assumed would be there. On this Windows machine, it isn't.

Bash(W="/c/Users/user/Desktop/GOLProductions/website-v2"; A="/d/work/my-app"; rm -f "$W/_mock.js" "$W/_shotc.html" "$W/_shotq.html" "$W/_shotq.js" "$A/public/_shot.html" "$A/public/_shot.js"; pkill -f "wrangler dev --port 8795" 2>/dev/null; taskkill //F //IM workerd.exe >/dev/null 2>&1; for f in "$W"/assets/assistant/*.js "$W"/assets/guard-*.js "$A/src/index.js"; do node --check "$f" || echo "FAIL $f"; done; for f in "$W"/functions/api/app/*.js "$W"/functions/api/app/assistant/*.js; do cp "$f" "$TEMP/c.mjs"; node --check "$TEMP/c.mjs" || echo "FAIL $f"; done; echo checked; cd "$W" && git status --short | grep -v "^ M .*\.html$" | head -30; cd "$A" && git status --short)
Error: PreToolUse:Bash hook error: pkill: not found

Recreated from the session in Claude Code’s style. The command and the error are verbatim, except the username, replaced with “user” for privacy. Check stopped the whole command before any part of it ran, so it couldn’t half-finish: delete some files, fail on the missing tool, and leave the server running. Claude’s next attempt dropped pkill and stopped the server with PowerShell instead.

02

What it checks today.

Each answer comes from your machine or the package registry, never a guess.

Programs that aren't there
The AI runs a tool your computer doesn't have, like jq or pkill. Check stops it, even when it's tucked inside another command.If the command checks for the tool itself first (command -v jq && jq), Check leaves it to the command.
Files, folders and scripts that aren't there
A folder cd would go to, a script node, bash, ruby or php would run, an npm run script, a Python module, or a file cat, ls or Get-Content would read. After cd somewhere &&, the rest is checked in that folder.
Packages that don't exist
Before anything is installed, the package's own registry is asked (npm, PyPI, crates.io, RubyGems, Packagist, NuGet, Homebrew, Chocolatey, the PowerShell Gallery), and so is the version. The same for packages run with npx and similar tools, Docker images, and new imports in JavaScript and TypeScript.With a private registry, Check stays silent rather than guess.
Git names that don't exist
A branch, tag or commit to switch to, merge or reset to; a remote to push to; a git command your git doesn't have.
Code that won't run
A command that won't parse, and code handed to node -e or python -c that won't parse. On Windows, Git Bash quietly changes \\ into \; when that would break the code, Check stops it first and says what changed.
Files that won't parse
Before a shell, Python, PowerShell or JavaScript file, or package.json, is written, its own parser is asked. A new .js file is left alone, because JSX and bundler code can't be read by Node.
Made-up library functions
A TypeScript edit that uses a function, method or option a library doesn't have, like _.smartMerge(). Your project's own TypeScript decides.TypeScript 5 or 6; if it takes longer than 2.5 seconds, the write goes ahead.
Copies that won't fit
A PowerShell folder copy that needs more space than the destination has, stopped before it fills the disk.Measured for up to 1.5 seconds; a destination that already holds files isn't judged.
The full list
Every check, with its exact limits: What Check does.
03

What it won't catch.

Where the machine can't give a definite answer, Check stays out of the way.

A file that isn't there.
A file a program opens by itself, like python app.py reading data.csv, runs and fails on its own. Check asks the reading tools (cat, head, ls, Get-Content), the script node, bash, ruby or php would run, and the folder cd goes to, not every file a program opens.
A file written in a roundabout way.
Files written with your agent's write and edit tools, a heredoc, or echo or printf of one quoted text are parsed. Anything more involved, like echo "$x" >> app.py, isn't.
Code that parses but is wrong.
Logic bugs, wrong maths, insecure code, a function that exists but does something else. Check proves things exist and parse; it doesn't judge what code means.
Library names it can't see.
Made-up functions in plain JavaScript, in Python, in libraries without type definitions, and in TypeScript 7 projects.
A made-up name that happens to be real.
Check lets it through, because the command is real.
A real command that does the wrong thing.
Like deleting a folder in your project that you meant to keep, or force-pushing. Check asks whether something exists, not what you meant to do.
What happens after.
An agent saying "done" or "tests pass" when they don't. Check works before each action, not after.
Private sources.
Packages from a private registry, Docker images from another registry or a private repository, and Go modules: from outside, missing and private look the same.
Anything your machine can't answer for sure.
Check lets it through rather than guess: commands run through eval, env, xargs, sudo or a login shell, anything after a cd that isn't the first thing in the command, or after an install, a script an earlier part of the same command may have made, and PowerShell commands that load a module, define a function or alias, or test for the program themselves.

Check is not a security tool. You still need one.

04

Your data.

What leaves your machine, and what never does.

Sent
For each message you send, its identifier only, never its text. For each command, the command text, with some credential patterns redacted, plus the working folder with your username masked and the results of the checks your machine ran. For each file write, the file's name, its size and whether it already exists, and, if a parser rejects it, the parser's one-line error message, which can quote the word it stopped at, and for JavaScript or TypeScript the names of npm packages it starts importing, with whether each is installed or declared. To know which AI tool is asking, the layout of the tool's message: the names and lengths of its fields, never what's in them.Not all credentials are caught: a secret in a PowerShell variable assignment is sent as written.
Never sent
Your prompts, on current installs. File contents: when Claude writes or edits a file, Check parses it on your machine and sends only the parser's verdict.
Kept
A record of each check (time, key hash, network, version, tool, verdict). With improvement records on (new keys, switchable at the console), also the command with credentials removed and the reason. Never your messages or file contents. Everything we keep is listed in our privacy policy.
Account events
Install, uninstall, key created, top-up, with your OS and a truncated account ID. Never command content.

Installs made before 24 September 2026 still send each prompt to an endpoint we retired that day; it discards the prompt unread, stores nothing and charges nothing. Reinstalling Check stops it being sent.

We have our own key that we use on our own machine. We sometimes share what it catches as examples. We never share anything from yours.

What runs where. The Check client runs on your machine, in ~/.check, before each command and file write. It decides nothing: it tells our server what the AI is about to do and answers its questions, using your own shell, git and parsers, and only about names the command contains. Every decision is made on our server and isn't published. The client is readable and signed by us, and accepts updates only with that signature. The way to know if Check works is to use it: if it catches something you would have missed, it's working. If it misses something, you'll know before we do.

05

Questions it answers.

The problems people ask about, and how Check stops each one.

Your AI is going to make up another thing.

Check catches it first. 100 free blocks, no card. Then A$0.10 only when it stops something.