How it works

Five steps. You will be screening by lunch and stopping threats by next week.

  1. 1Make an account
  2. 2Set up your project
  3. 3Add custom rules and settings
  4. 4Monitor your traffic
  5. 5Stop threats

Part one, the five steps

1

Make an account

Sign up and your org is created on first login. You land on an empty dashboard with a key waiting for you.

Nothing is screened yet, and nothing is enforced.

2

Set up your project

Name your deployment, take its key, and wrap your model call. Two calls around the thing you already have. No proxy, no gateway, no DNS.

  1. One deployment per bot or agent

    Each keeps its own key, thresholds and behavior when things break.

  2. Starts in monitor mode

    Scores and logs everything. Blocks nothing until you say so.

python
# pip install killswitch    (or: npm i @fermi/killswitch)

try:
    ks.screen_user_message(text, conversation_id=convo_id)
    reply = llm.generate(text)
    ks.screen_ai_reply(reply, conversation_id=convo_id)
    return reply
except MessageBlocked as e:
    return e.fallback_reply
3

Add custom rules and settings

Write the things a score will never catch on its own, in plain English, and decide where the lines sit.

  1. Rules catch policy

    Never quote a discount. Never promise a refund. Never give a dosage. Live in seconds, no deploy.

  2. Thresholds catch harm

    A score per category. You pick the level where stopping starts.

  3. Fail open or fail closed

    What happens to a message if the scorer is unreachable. Your call.

Plain-English rules with a live test box
Plain-English rules with a live test box
4

Monitor your traffic

Everything gets scored and logged, and nothing gets stopped. Leave it alone for a week, then go and read what your users have actually been sending you.

Everybody wants to skip this one. Don't.

  1. Every message on one canvas

    Zoom, pan, and see which branch is carrying the trouble.

  2. Replay your thresholds

    Move the sliders against those seven days and see what would have changed.

Event map
5

Stop threats

Flip the deployment to enforce and the same rules and thresholds start acting instead of just recording. Three levels, and you pick how far each one reaches.

  1. Block a message

    One reply stopped, fallback sent, conversation carries on.

  2. Kill a conversation

    Thread is done. Every call after it fails in milliseconds.

  3. Halt everything

    One switch, every deployment, about a second. Works even if the scorer is down.

AI traffic running

Part two, what is actually happening

What one call does, start to finish

Half a second, and most of that is the scorer. Everything either side is a couple of indexed reads and one insert.

  1. Your call arrives

    0 ms

    Message, conversation id, deployment. One request.

  2. Two cheap reads

    5 ms

    Org halted? Conversation already dead? If either, it stops here and never touches a model.

  3. The scorer reads it

    400 ms

    Your categories, your active rules, the last few turns of context. Answers in strict JSON.

  4. Rules, then thresholds

    1 ms

    A matched rule wins outright. Otherwise your thresholds decide, on harm scores alone.

  5. Written, then returned

    8 ms

    Appended and hash-chained before the call comes back, so the log can never lag behind the verdict.

What the scorer sends back:

json
{
  "scores": {
    "privacy_pii_leak": 96,
    "illegal_activity": 40
  },
  "risk": 96,
  "matched_rule_ids": ["r_8f21"],
  "reason": "The agent tried to send a
    customer data export to an address
    outside the company domain."
}

Autopilot, in detail

Four settings decide what happens without you. Every one of them is versioned, and every event records which version judged it.

  1. Message block

    default 85

    Block the message when any harm category scores at or above this. One number, checked on every message in and out.

  2. Conversation kill, on one message

    default 95

    A single message this severe ends the whole thread on its own, without waiting for a pattern to build.

  3. Conversation kill, on a pattern

    3 flags in 10 turns

    Nothing severe enough to kill alone, but it keeps happening. Set what counts as a flag, how many it takes, and how far back to look.

  4. Automatic super kill

    off by default

    Halt the entire organization when a share of live conversations gets killed inside a short window. That is what a coordinated attack looks like, and it is off until you turn it on.

Autopilot thresholds with a seven day replay
Autopilot thresholds with a seven day replay

Move anything and the preview replays your last seven days of real traffic against the new numbers, so you see how many more or fewer stops you would have had before you save.

A matched rule always wins outright. Autopilot only gets a say when nothing matched, and it decides on the harm scores alone, so breaking a policy that is not actually dangerous blocks the message rather than killing the thread.

Why the log holds up

Every event carries a hash of its own contents plus the hash of the row before it. Change one row and its hash stops matching. And because the next row came from it, everything after it breaks too.

Nothing can update or delete those rows, and that includes us and the model being screened. Give a model tools and a goal and it will sometimes go looking for its own oversight, so the log it writes to is one it cannot reach back into. An override appends a new event pointing at what it reverses. Releasing a halt appends a release. Nothing is ever edited away.

Every night a job walks the whole chain and writes down what it found, pass or fail. If the chain is broken it withholds that day's anchor, so a break can never be laundered by a published hash.

sql
-- every row is chained to the one before it
hash = sha256(prev_hash || canonical_json(row))

-- and the table refuses to be rewritten, by anyone
revoke update, delete on events
  from public, anon, authenticated, service_role;

create trigger events_no_update_delete
  before update or delete on events
  for each row execute function reject_update_or_delete();

How it is built

Your model, or ours

The scorer is any OpenAI-shaped endpoint. Start hosted, then point three environment variables at your own vLLM box and nothing leaves your infrastructure.

Halts reach every process

A halt is just a row in a table. It reaches every connected SDK over Realtime in about a second, and gets re-checked on every call. It does not need the scorer to be up.

It is all Postgres

Row level security scopes every read to your org. Retention, anchoring and verification all run as scheduled jobs in the same database that holds the log.

Start at step one

Do one and two today. Then leave it in monitor for a week and see what it catches.