Developer preview · for Claude Code

A memory, a safety brake, and proof the job got done.

Claude Code is an AI developer that runs on your computer and writes, edits, and ships software for you. Killer Instinct is the layer underneath it: a memory of what actually works in your codebase, a guard that blocks known-catastrophic commands before they run, and a loop that checks whether the work actually shipped. Once installed it runs automatically - the guard screens every command, and every commit logs itself into a memory that compounds. No opt-in.

~117 msguard overhead per command - it screens, it doesn't slow you down
12 / 12guard test cases pass, zero false positives on safe commands
survives a crasha job's result recovered after the agent was killed mid-run
New to this? Start here

What Killer Instinct is, in plain language.

An AI coding assistant like Claude Code is genuinely powerful - but on its own it has three blind spots. Killer Instinct fixes each one.

🧠

It forgets everything

Every new session starts from zero. It re-learns - and re-breaks - the same things about your project over and over. KI gives it a memory of what worked here before, so it picks up where it left off.

🛡

It can act dangerously

One wrong command can delete work or break something running in production. KI checks every command against hard safety rules and blocks the known-catastrophic ones before they run - rules the assistant itself doesn't control.

✅

It can't tell if it worked

It writes code and assumes success - it never double-checks that the change actually reached your real site or app and is still working. KI closes that loop: it checks the real outcome and records it.

Think of an AI coding assistant as a brilliant engineer with no memory of yesterday and no idea whether their last change actually worked. Killer Instinct is the notebook, the seatbelt, and the receipt - the layer that turns a brilliant but forgetful helper into one you can actually trust.
How it works

Remember → Guard → Act → Verify.
A loop that compounds.

Two hooks wire in on install and run the loop automatically: a guard screens every shell command before it executes, and an auto-instrument logs a graded episode from every commit - no opt-in. A set of MCP tools (the open standard Claude uses) add recall and verified execution on top. The loop compounds whether or not the assistant remembers to reach for it.

01 REMEMBER

What worked here

ki_recall / ki_boot return the gotchas and proven steps for this project, so Claude doesn't re-derive a brittle path - or repeat a known mistake.

02 GUARD

Block the catastrophe

ki_check screens a command against a deny-list of hard invariants. A command that would wipe files or touch a protected system is blocked before it runs.

03 ACT

Hands with a receipt

ki_do runs the command and returns the real result - exit code and output - and can launch detached jobs that outlive the session and survive a crash.

04 VERIFY

Did it actually ship?

KI opens a record keyed to the commit; a detached watcher checks the real outcome - the commit landed on the branch, or the deploy is reachable on your version endpoint - and grades it. Ambiguous results are marked ambiguous, not "shipped".

For technical teams - skip ahead if you just wanted the gist
Built for individual developers today · team features in early access

The technical case.

The hard part of agentic development isn't how smart the model is - it's that every session is stateless, nothing tells the agent whether its work succeeded downstream, and there are no safety limits on your real systems. KI is the per-machine layer that addresses all three. Every install gets its own isolated org - data and commands invisible to other tenants, live today; cross-machine team pooling and SSO are on the roadmap.

🧠

Persistent project memorylive

Cross-session recall of the gotchas and procedures that actually worked in this codebase, scored as they get reused (proven). The grading engine is live; the graded action-to-outcome corpus is young and grows with use - it is the mechanism, not yet a large dataset.

🛡

A guard on the execute pathlive

A deny-list of hard invariants, in code below the model, blocks known-catastrophic command classes before they run - on the cloud route and in the local agent. It is a backstop, not a sandbox: intentionally permissive so it never blocks legitimate work, the agent doesn't control it, and blocked attempts are logged. It catches the catastrophe classes it knows; it is not a substitute for review.

♻

Crash-survivable handslive

Detached jobs that outlive the session and survive an agent restart - results live on disk and reconcile on startup. A native shell's background process dies with the session; these don't, so a long migration or deploy finishes and reports even across a crash.

🔗

The outcome looplive

An action opens a record keyed by commit SHA; a detached poller checks the real result - did the commit land, is the deploy reachable - and writes the graded outcome back to the exact action that caused it. A hard join key, not timestamp guesswork. Proven on a real deploy; provider coverage grows.

🌐

Vendor-neutral by designby design

Built on open MCP plus a local HTTP agent, so your memory and outcomes aren't locked to one vendor. Wired to Claude Code today; other agents are on the roadmap. The model becomes the swappable part; the layer is the constant you own.

🔒

Yours, on your machinelive

A local agent you run, authenticated by a per-device token you issue and revoke (backwards-compatible with a legacy key during migration). What stays on your machine vs what reaches the KI brain is spelled out below - and the brain can be self-hosted.

Data boundary

What stays local, what leaves.

Plainly, because trust depends on it - and because "local-first" has to mean something specific.

Stays 100% on your machine

The guard and its rules. Command execution and the real stdout/exit codes. Detached job results on disk. None of this is sent anywhere.

Sent to your KI brain

The memory and outcome records (what worked, the graded results). By default the brain is hosted at call-os.com; point KI_BRAIN_URL at your own instance to keep everything on infrastructure you control. That is the only network egress.

Build vs buy

Why not just build this yourself?

You could. Each piece - a command deny-list, a detached job runner, an outcome poller, a memory file - is individually a few days of work. What isn't a few days is the part that actually matters: getting the integration correct, and the value that only accrues over time.

  • The integration is the hard partCorrect crash reconciliation, an honest action-to-outcome join key, curated invariants that block catastrophes without false positives, and a scoring layer that is statistically honest - that's the engineering, not the scaffolding.
  • The corpus only compounds with useThe asset is the accumulated, private record of which actions actually produced results in your codebase. That takes months of real work to build - it can't be bought or back-filled.
  • It's yours, and it's neutralThe record lives with you, not on a model vendor's balance sheet - and it works across agents, so you're not rebuilding it the day you switch models.
Grounded in truth

What's live today - and what's coming. No theater.

We would rather show you exactly where the line is than sell you a demo. The mechanism is real and proven on a developer machine; the numbers are small and honest because the corpus is young.

Live today

  • The guard on the execute path - cloud route + local agent block commands that would wipe files or touch protected systems; 12/12 test cases, safe work passes.
  • Crash-survivable detached jobs - verified by killing the agent mid-job and recovering the result on restart.
  • Cross-session project memory + warm-start - real recalled gotchas and procedures, scored by reuse.
  • The outcome loop - auto-closed a real deploy to "deployed" with no session open.
  • Self-serve, isolated orgs - one signup mints a private tenant; data + commands invisible to other orgs (verified by isolation tests).
  • Per-device tokens - issue, authorize, revoke. Backwards-compatible with the legacy key.
  • Local hands, supervised - the installer drops in the local agent, starts it, and registers a supervisor that auto-restarts it on crash and survives reboot; ki_do runs guarded, crash-survivable jobs on your machine (respawn + isolation proven).
  • The flywheel, auto-wired - the installer wires a guard on every command plus an auto-instrument that logs a graded episode per commit; the corpus fills from real work, no hand-logging.
  • The self-closing guard - every command the guard blocks becomes a graded negative episode (proven live), so the guard mints the reliability corpus it will later, with your one-tap approval, enforce. No network in the blocking path.

Coming / early access

  • A larger graded corpus - reflexes turn on as each context crosses statistical significance; today it's filling.
  • Team pooling - share outcomes across your team's machines into one private brain. Per-org isolation is live; cross-machine pooling is next.
  • One-click signed installer, SSO / RBAC, org dashboard - for team rollouts (the agent + guard hook ship today; the installer is unsigned preview).
Get Killer Instinct

Install the developer preview.

A lean, secret-free package - unsigned developer preview, so review the scripts before running them (they're short). Requires Node 18+ and Python; Windows-first today. The local guard, the hands (a small agent the installer starts), and execution all install locally; the memory + outcome brain connects with a key you issue.

Download Killer Instinct (zip)

~40 KB · no bundled secrets · pinned lockfile. Two runtime deps fetched on install: @modelcontextprotocol/sdk@^1.12.0, zod@^3.23.8. Sole network egress: your KI brain (call-os.com by default, or your own KI_BRAIN_URL).

SHA-256: 6d11b1ac6a4caaa7171751c277f2707bef8e54e1f7c878257d0093ac98e3d58c

1 · Unzip and install deps

Unzip, then in the mcp folder run npm install --omit=dev to fetch the two pinned runtime dependencies (or use the air-gapped vendored bundle - ask us).

2 · Get your key + register

One command on Windows: setup.ps1 creates your own private, isolated org automatically (or pass -Pin to reuse a key), builds, and registers KI with Claude Code. Unsigned preview - read the script first.

powershell -ExecutionPolicy Bypass -Scope Process -File installer/setup.ps1 -CodeToo

Prefer to do it by hand? Provision a key, then register:

# create your private org -> returns your KI key (save it):
curl -X POST https://call-os.com/tapdeck/api/signup

setx KI_PIN "ki_your-key"     # store it; reopen the terminal
claude mcp add killer-instinct -s user \
  -e KI_BRAIN_URL=https://call-os.com/tapdeck \
  -e KI_PIN=%KI_PIN% \
  -- node ./killer-instinct/mcp/dist/index.js

3 · The flywheel is wired for you

setup.ps1 merges two hooks into your ~/.claude/settings.json (backed up first, never clobbered): a guard that screens every shell command, and an auto-instrument that logs a graded episode per commit so the corpus fills itself. Manual form, if you registered by hand:

"PreToolUse": [{ "matcher": "Bash|PowerShell", "hooks": [
  { "type": "command", "command": "node ./killer-instinct/hooks/ki_guard_hook.js" } ]}],
"Stop": [{ "hooks": [
  { "type": "command", "command": "node ./killer-instinct/hooks/ki_episode_hook.js" } ]}]

4 · Restart your session

Claude Code now has the KI tools - ki_recall, ki_boot, ki_check, ki_do, ki_job, ki_learn, ki_record_outcome, ki_simulate, ki_status, ki_start_agent, ki_handoff.

Maintenance & compatibility

KI sits under your workflow, so durability matters: it tracks the MCP standard and the Claude Code hook/settings format, is versioned, and is tested against current Claude Code. It's a single-maintainer developer preview today - an open-source release is planned so adopters aren't exposed to single-maintainer risk. Questions, breakage, or enterprise needs: reach out below.

Where it's going

From a tool you use to a layer you can't work without.

The loop now runs automatically on every commit, so the corpus fills itself from real work. As each context crosses statistical significance, recall stops returning hand-written notes and starts returning proven plays - the agent gets measurably better at your codebase the more it works in it. From there it generalizes: more verified actions become graded outcomes, pooled privately across a team's machines into one brain no model vendor can assemble, because none of them can see your results - with redaction, tenant isolation, and owner-controlled retention shipping before any pooling does. The endgame is the user-owned, vendor-neutral substrate every coding agent plugs into: the model is the swappable engine; the memory, the hands, and the proof are yours and travel with you.

A memory, a safety brake, and a receipt

Stop shipping blind.

One install. Claude Code gets a memory of what works in your codebase, a guard it doesn't control, and a loop that checks whether the work actually shipped. Local-first. Vendor-neutral. Yours.