How it works
Five steps. You will be screening by lunch and stopping threats by next week.
Part one, the five steps
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.
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.
One deployment per bot or agent
Each keeps its own key, thresholds and behavior when things break.
Starts in monitor mode
Scores and logs everything. Blocks nothing until you say so.
# 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_replyAdd custom rules and settings
Write the things a score will never catch on its own, in plain English, and decide where the lines sit.
Rules catch policy
Never quote a discount. Never promise a refund. Never give a dosage. Live in seconds, no deploy.
Thresholds catch harm
A score per category. You pick the level where stopping starts.
Fail open or fail closed
What happens to a message if the scorer is unreachable. Your call.

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.
Every message on one canvas
Zoom, pan, and see which branch is carrying the trouble.
Replay your thresholds
Move the sliders against those seven days and see what would have changed.

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.
Block a message
One reply stopped, fallback sent, conversation carries on.
Kill a conversation
Thread is done. Every call after it fails in milliseconds.
Halt everything
One switch, every deployment, about a second. Works even if the scorer is down.

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.
Your call arrives
0 msMessage, conversation id, deployment. One request.
Two cheap reads
5 msOrg halted? Conversation already dead? If either, it stops here and never touches a model.
The scorer reads it
400 msYour categories, your active rules, the last few turns of context. Answers in strict JSON.
Rules, then thresholds
1 msA matched rule wins outright. Otherwise your thresholds decide, on harm scores alone.
Written, then returned
8 msAppended and hash-chained before the call comes back, so the log can never lag behind the verdict.
What the scorer sends back:
{
"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.
Message block
default 85Block the message when any harm category scores at or above this. One number, checked on every message in and out.
Conversation kill, on one message
default 95A single message this severe ends the whole thread on its own, without waiting for a pattern to build.
Conversation kill, on a pattern
3 flags in 10 turnsNothing 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.
Automatic super kill
off by defaultHalt 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.

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.
-- 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.
