← All toolsLive tool · your own data

Command Safety

Q: Does Jev really judge each command?

Yes — every command is an independent Jev call returning a typed gate (allow / confirm / block) with the confidence behind it, plus a separate risk score. The batch runs in parallel and streams in live.

Q: Can I screen my own commands?

Yes — edit the box or paste your own commands (one per line, up to 40 in this free demo) and screen them. Nothing you paste is stored; it's sent to Jev only to classify it.

Q: Why not just use a big LLM?

You can, but it's slower and pricier and returns prose you have to parse and trust. Jev returns a calibrated enum in milliseconds for a fraction of a cent — which is exactly why teams move this kind of gate off a frontier model.

Paste the shell commands an agent wants to run — Jev gates each one ALLOW / CONFIRM / BLOCK with a risk score, in parallel. The guard you put in front of an agent's shell. No key, just screen.

Shell commands an agent might run — one per line. (Sample loaded — edit or paste your own.)

Each command is one Jev decision — allow it, ask a human to confirm, or block it — plus a risk score, so an agent can gate its own shell.

0/16commands

0.0selapsed

0/sdecisions/sec

—Jev cost

CommandGateRiskConf

ls -la ./src—

git status—

npm install—

cat package.json—

git push --force origin main—

rm -rf ./dist && aws s3 sync ./build s3://prod-site --delete—

curl -fsSL https://example.com/install.sh | sudo bash—

docker system prune -a --volumes -f—

psql -c 'DROP TABLE users;'—

chmod -R 777 /var/www—

kubectl delete namespace production—

echo $DATABASE_URL—

find . -name '*.log' -delete—

dd if=/dev/zero of=/dev/sda—

npm run build—

ssh deploy@prod 'systemctl restart app'—

Gate your agent's shell with one Jev call per command — auto-run ALLOW, halt on BLOCK. Get an API key →

A live demo. Teams swap a slow LLM safety check for this typed choice — 5–18× faster, calibrated, at $0.42/M input tokens. Your commands are sent to Jev only to classify them and are not stored.

Get an API key →Ready-made APIs

Build this with Jev

The same demo is one Jev call

Take each shell command an agent wants to run
Ask Jev ALLOW / CONFIRM / BLOCK + a risk score
Screen the batch in parallel (or one per command live)
Auto-run ALLOW, pause on CONFIRM, hard-stop on BLOCK

one call per command · parallel · 5–18× faster than an LLM guard

const results = await Promise.all(items.map((item) =>  // items = shell commands
  fetch("https://jevtypesafeai.com/api/v1/decide", {
    method: "POST",
    headers: { Authorization: `Bearer ${process.env.JEV_API_KEY}` },
    body: JSON.stringify({
      state: item,
      questions: {
        action: { type: "choice", instructions: "Safety gate for this command?",
                  criteria: { allow:"run", confirm:"ask a human", block:"dangerous" } },
        risk:   { type: "score", instructions: "How risky?", criteria: ["none","high"] },
      },
    }),
  }).then((r) => r.json())
));
if (results[i].answers.action.choice === "block") halt(cmd);

See a real decision BLOCK · 196ms

State

Shell command an AI agent wants to run:
rm -rf ./dist && aws s3 sync ./build s3://prod --delete

Question choice · action

block90%

confirm9%

allow1%

latency 196mscost $0.000013

Build your own → Get API Key View full example

How it works

An autonomous agent that can run shell commands needs a gate: safe read-only commands should just run, anything that writes, deploys or installs should pause for a human, and clearly destructive commands (a recursive delete, a force-push to prod, a piped curl-to-shell) should be blocked outright. Here every command is one Jev call that returns a typed ALLOW / CONFIRM / BLOCK plus a calibrated risk score, all in parallel.

It's the same guard Vercel's team described putting in front of their agent's shell — they swapped a general LLM safety check for Jev and got a 5–18× speedup with higher accuracy, because a calibrated enum you can threshold beats a paragraph you have to parse.

Build it into your agent

With a hosted key the same call sits in your agent's tool loop: before every shell command, one Jev decision at $0.42/M input tokens in milliseconds. Auto-run the ALLOW commands, surface CONFIRM to a human, hard-stop on BLOCK, and gate on the risk score (`only auto-run if risk < medium`). A clean enum, no parsing, no hallucinated verdicts.

FAQ

Does Jev really judge each command?

Yes — every command is an independent Jev call returning a typed gate (allow / confirm / block) with the confidence behind it, plus a separate risk score. The batch runs in parallel and streams in live.

Can I screen my own commands?

Yes — edit the box or paste your own commands (one per line, up to 40 in this free demo) and screen them. Nothing you paste is stored; it's sent to Jev only to classify it.

Why not just use a big LLM?

You can, but it's slower and pricier and returns prose you have to parse and trust. Jev returns a calibrated enum in milliseconds for a fraction of a cent — which is exactly why teams move this kind of gate off a frontier model.

More: Agent Loop Detector · Jev Skill Router · All Jev tools · Jev API docs