How it works

Three steps to leave it running.

No account and no network. Your agents keep working, and Memnox answers before anything runs.

  1. 1

    Set it up once

    One command finds every agent on your machine and what each one can reach, then puts Memnox where their work has to pass. It writes down where your secrets are, never what is in them, and nothing leaves the machine.

    memnox setup
    $ npm i -g memnox && memnox setup ██   ██ ██████ ██   ██ ██   ██  █████  ██   █████ ███ ██     ███ ███ ███  ██ ██   ██  ██ ████ █ ██ █████  ██ █ ██ ██ █ ██ ██   ██   █████   ██ ██     ██   ██ ██  ███ ██   ██  ██ ████   ██ ██████ ██   ██ ██   ██  █████  ██   ██ ▄▄   ▄▄ ▄▄▄▄▄▄ ▄▄   ▄▄ ▄▄   ▄▄  ▄▄▄▄▄  ▄▄   ▄▄ ┌  memnox setup │ ◇ Looking for agents on this machine│ ◇ Found 3 agents│ Claude Code, Cursor, Codex CLI│ ◇ What they can reach today ╭───────────────────────────────│   mcp         4 servers│   can reach   ~/.ssh, ~/.aws/credentials, .env│ ╰─────────────────────────────────────────────────────────│ │   Put them under Memnox?  [y/N] y◇ Wired this machine│ 18 interceptors, 9 rules, daemon installed, Claude Code takes a lease before writing, 4 MCP server(s) through the proxy│ └ This machine is under Memnox.   Nothing left this machine: no account, no key, no network call.
  2. 2

    Watch a day of real work

    The first install refuses nothing. Every answer is written down, so after a day you can see what a rule would have stopped and what your agents never needed, before it costs you anything.

    memnox timeline
    $ memnox timeline --only blocked --since 7d ██   ██ ██████ ██   ██ ██   ██  █████  ██   █████ ███ ██     ███ ███ ███  ██ ██   ██  ██ ████ █ ██ █████  ██ █ ██ ██ █ ██ ██   ██   █████   ██ ██     ██   ██ ██  ███ ██   ██  ██ ████   ██ ██████ ██   ██ ██   ██  █████  ██   ██ ▄▄   ▄▄ ▄▄▄▄▄▄ ▄▄   ▄▄ ▄▄   ▄▄  ▄▄▄▄▄  ▄▄   ▄▄ ┌  memnox timeline │ ◇ claude-code  ses_7f3a2c  2026-10-07 ╭─────────────────────│   Time             Action│   14:05:31  ✗deny  filesystem.read .env│   14:22:08  ✗deny  git.push-force main│   15:40:52  ●ask   postgres.write production│ ╰─────────────────────────────────────────────────────────│ └ 3 action(s) across 1 session(s).   One of them end to end: "memnox trace <id>".
  3. 3

    Let it run without you

    Switch the machine to autonomous and walk away. Most actions never ask, a refusal tells the agent what to do instead, and only what a rule marks ask waits for a person, on their phone or in Slack, Discord or Teams.

    memnox mode
    $ memnox mode autonomous ██   ██ ██████ ██   ██ ██   ██  █████  ██   █████ ███ ██     ███ ███ ███  ██ ██   ██  ██ ████ █ ██ █████  ██ █ ██ ██ █ ██ ██   ██   █████   ██ ██     ██   ██ ██  ███ ██   ██  ██ ████   ██ ██████ ██   ██ ██   ██  █████  ██   ██ ▄▄   ▄▄ ▄▄▄▄▄▄ ▄▄   ▄▄ ▄▄   ▄▄  ▄▄▄▄▄  ▄▄   ▄▄ ┌  memnox mode │ ◇ autonomous mode ╭─────────────────────────────────────────│   lets through  the work: edits, tests, commits, pushes, pull requests, reads anywhere│   stops         money, deploys, authority, deletes outside the machine, and any change in production│ ╰─────────────────────────────────────────────────────────│ └ autonomous mode is on for every agent on this machine.   memnox mode off   back to your own rules. The rules are in ~/.memnox/mode.policies.toml

One call, answered in order.

Which agent asked, the rule it meets, the answer, what runs, and the record it leaves. Pick a place below to watch another.

Claude Code hooks: The refusal that still finishes the work. Claude Code, mid task, filesystem.read · .env, attributed first (claude-code · fix the failing auth tests), is checked against the rule "secrets-not-required": A task that declared no credential need does not get to read one. The verdict is denied, .env.example named instead, and it is then applied at every surface the agent tried to reach. The result is appended to the record, which now holds 0 rules across 4 agents and which every later decision is measured against.

Agent
Rule
Answer
Runs
Record
decision.dec_01JQ2.json
AllowAskDeny
Kept on this machine
rules in force0
agents4
answers on record0
Claude Code, mid task
filesystem.read · .env
Who is asking
claude-code · fix the failing auth tests
Compare the request against the task
secrets-not-required

A task that declared no credential need does not get to read one.

actionfilesystem.read
holdsaws key, database url
scopetask declared none
verdictdenied, .env.example named instead
Evaluate
Comparing scope…
read · .env
checking the path…
read · .env.example
the named alternative…
shell · npm test
running the suite…
github · create_pull_request
opening the change…
Where Memnox stands

One answer wherever agents act.

No agent stops to ask on its own. So Memnox stands where its work has to pass, and answers before anything runs.

What the agents tried today
  • Claude Codegit push --force origin mainshell.executeInstead: push a branch and open a PRDeny
  • Cursorgithub.merge_pull_request #412mcp.*Bo answered on Slack: allow onceAsk
  • Codex CLIcurl https://paste.example.comhttp.requestHeld: no rule covers this hostAsk
  • Hermesgit push origin fix/flaky-testgit.credentialA branch, so it ran on its ownAllow
  • OpenClawopen dashboard.stripe.combrowser.navigateAsked once for this siteAsk
Example
  1. Commands

    A refusal comes with a way

    Every command is checked before it runs, and a line with two commands is judged by the worse one. A denied one tells the agent what to do instead, so it keeps working.

    Cannot seea shell started outside the intercepted PATH

  2. Tool calls

    Writes ask the person who owns them

    One wrap covers Claude Code, Cursor, Cline, VS Code and OpenClaw. Reads go through at once; a merge, a send or a refund waits for its owner.

    Cannot seewhat the model is thinking, and anything it does without calling a tool

  3. The network

    Nothing leaves for a new address quietly

    The hosts your work already uses answer at once. An address no rule covers waits for somebody to say yes.

    Cannot seewhat is inside an encrypted request, and any traffic that skips the proxy

  4. Git logins

    Even an agent nobody wrapped is ruled

    To push, any agent has to ask git for a login. Memnox decides which server gets one, and it stores no secret it could hand out.

    Cannot seea login the agent is already carrying

  5. The browser

    A signed in browser asks first

    A browser agent arrives logged in as you. It asks once per site, and a yes holds for the session.

    Cannot seewhat a page does once you have allowed the site

Agents you cannot wrap still pass through

To push code an agent has to ask git for a login. To reach a server it has to look up the address. Both are places a rule can sit, and the agent never has to cooperate or even know.