Memnox MCP server
Commit Nov 12, 2026An open source runtime that enforces safety boundaries for AI coding agents by ruling on every tool call with allow, ask, or deny verdicts.
Also known as Memnox/memnox-runtime
- Stars
- 11
- Tools
- —
- Downloads, 30 days
- —
- Latest version
- —
- Last commit
- Nov 12, 2026
- License
- Apache-2.0
What is Memnox MCP?
Memnox is an open source runtime that enforces safety boundaries for AI coding agents by ruling on every tool call with allow, ask, or deny verdicts.
Summary generated from the project's README
About Memnox MCP server
Securing AI coding agents by enforcing safety boundaries is what memnox-runtime enables for developers using tools like Claude Code, Cursor, or Windsurf. It acts as a local runtime that sits within the agent's execution loop to evaluate every tool call—including filesystem access, shell commands, git operations, and MCP calls—before they execute. By providing allow, ask, or deny verdicts, it ensures that autonomous agents operate strictly within your defined project constraints without requiring any external accounts.
Users set up the system locally using Node 22 or newer via a simple setup command that installs a daemon to manage rules. The runtime uses platform-specific mechanisms like sandbox-exec on macOS or Landlock on Linux to maintain security. It distinguishes itself by providing agents with a memnox-session MCP server, allowing them to query project memory, understand code fingerprints, and receive guidance on why certain actions were refused so they can complete tasks without stalling.
What you can do with it
- 1Managing agent autonomy with human oversightDevelopers can intercept sensitive tool calls by requiring manual approval through existing chat interfaces or messaging apps.
- 2Auditing agent actions during a sessionYou can ask your agent to explain its recent history or why a specific command was blocked by the runtime.
Written from the project's README. Every use case is checked against a quote from it.
Automated checks
Ran Nov 14, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachablememnox/memnox-runtime is public and reachablegithub.com/memnox/memnox-runtime ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)Apache-2.0spdx.org/licenses/Apache-2.0.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-12github.com/memnox/memnox-runtime ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubMemnox runtime
Your agents can already do the work.Memnox makes it safe to let them do it in your boundaries.
One boundary of allow, ask and deny over every agent on your machine, ruled before each tool call runs. No model decides anything, and nothing leaves your machine.
Quick start · Inside a session · Agents · Apps · Code fingerprint · Terminal · Docs
Agents stay autonomous. Memnox sits in their loop rather than in front of it, and answers every call before it runs.
Memnox is an open source runtime that tells you what you can safely let your AI coding agent do next. It rules on every tool call Claude Code, Codex, Cursor, Gemini CLI or Windsurf makes, before the call runs, with one of three verdicts: allow, ask or deny. It runs on your machine and needs no account.
What is allowed goes ahead. What is denied is refused with a way forward, so the agent
finishes the task instead of stalling. What needs a person asks you in the prompt you are
already looking at. Once you have said yes to the same thing often enough, memnox next
names it as something you could stop being asked about.
You do not learn a new tool to get that. You set it up once and keep working the way you work now.
Quick start
npm install -g memnox
memnox setup
That is the last Memnox command you need. setup finds the agents on this machine and goes
through them one at a time: what each can already reach, what you want to call it, and
whether to put it under Memnox. Nothing is changed for an agent you say no to.
Claude Code
claude-code
id agt_claude-code
config ~/.claude.json
mcp github
can use shell, filesystem, git, network, mcp
can reach ~/.aws/credentials, network
Call it something acme will recognise, or press Enter to keep "Claude Code" > Backend Coder
Put Backend Coder under Memnox now? [Y/n] y
For each agent you accept, it puts a hook in front of every tool call, gives the agent a
small MCP server (memnox-session) it can ask Memnox through, and adds a /fingerprint
command. It also has the machine start the daemon that holds the rules. Then you open your
agent the way you always do. There is nothing to launch and nothing to remember.
Want to look before you change anything? npx memnox reads the agent configs on your
machine and prints what each can reach. It changes nothing and needs no account, and
what your agents can reach shows
what it finds.
Requirements
Node 22 or newer. Everything starts in observe, which records what every rule would have said and stops nothing, until you switch to enforce.
| The daemon is started by | It listens on | Kernel guard | |
|---|---|---|---|
| macOS | launchd, as a user agent kept alive | a unix socket in ~/.memnox |
sandbox-exec |
| Linux | systemd, as a user unit restarted on failure | a unix socket in ~/.memnox |
Landlock |
| Windows, natively | Task Scheduler, at logon | a named pipe for your account | none yet |
| Windows, in WSL | the same as Linux | the same as Linux | Landlock |
memnox setup installs the daemon for you, and memnox daemon --install, --status and
--uninstall manage it by hand. On Windows the MCP proxy, the interceptors and Claude
Code's hook govern agents on the Windows side, but there is no kernel guard, a task is not
restarted after a crash, and a named pipe is not the owner only boundary a socket is, so
WSL is still the stronger choice. memnox doctor says which agents are governed natively,
and ADR 0003 says what is and is not verified there.
What you get, inside every session
| When | What Memnox does | What you typed |
|---|---|---|
| A session starts | The agent is told the boundary it works in, the rules in force, what your team has settled and how this repository is built, so it plans around them instead of walking into them | nothing |
| The agent reaches for something your rules refuse | The call never runs. The agent is told why and what to use instead, so it finishes the task rather than stalling | nothing |
| Something needs a person | You are asked in your agent's own permission prompt, in the conversation, on a paired app, or in your Slack or Discord DM. Yes once, yes for the session, or no | a yes or a no |
| The agent writes code that breaks how this repository is built | Refused before it lands, or sent straight back to be put right, even when the agent switches from its edit tool to the shell | nothing |
| Your prompt touches something your team already decided | The decision is put in front of the agent, with who confirmed it and where | nothing |
| Two agents go for the same file | The second is told who holds it and what they have been doing | nothing |
| You want to know why, what happened, or to undo it | Ask the agent in plain words: "why was that refused?", "what have you done this session?", "undo what you did" | a sentence |
You open Claude Code in a repository and ask it to add order cancellation. Before it reads a file, it has been told where it stands:
Memnox: Memnox rules on this session in enforce mode: a rule that refuses stops the call, and one that asks puts the question to the person.
Project boundary: ~/work/shop. A write outside it asks first.
Your workspace has settled 1 decision(s), policies and owners. Before you change code, ask the memnox-session "brief" tool about the paths, or "memory" about the subject, and cite what it says.
This repository states how its code is written, in .memnox/code-fingerprint.yaml. Follow it; a write that breaks an enforced line is refused.
Your prompt mentions payment retries, which your team settled in Slack, so that decision is put in front of the agent too:
Your workspace settled this about payment retries: "Declined payments are never retried." (a decision, confirmed by ada@acme.com, on 2026-05-02, source https://acme.slack.com/archives/C01/p17).
In a hurry, the agent writes the update straight into the HTTP handler. The repository sends every database write through an Action, so the write never lands:
Memnox: This repository's code fingerprint: all database writes go through Actions, which own transactions and event persistence (rule fingerprint:writes-only-in-actions)
Instead: call actionFactory.create(XAction.class).run(params)
It writes the Action instead, and when the work is done it tries to force push:
verdict DENY
reason you chose to deny this: it rewrites history somebody else may already have pulled
instead push a branch and open a PR
So it pushes a branch and opens a PR. You typed one prompt. Every one of those answers came back inside the conversation, and each is in the record when you ask the agent "why was that refused?"
Supported agents
Each agent's own hook asks Memnox before every tool call: a file read or write, a shell command, a web fetch, an MCP call. The answer comes back in the agent's own format, so the agent treats it like any other result.
| Agent | Checked before it runs | A question goes to | Told at session start |
|---|---|---|---|
| Claude Code | every tool | its own permission prompt | yes |
| Codex | every tool its hook reports | the conversation | yes |
| Gemini CLI | every tool | the conversation | yes |
| Cursor | commands, MCP calls, file reads and writes | its own prompt for commands and MCP calls | yes |
| Windsurf | commands, MCP calls, file reads and writes | memnox approve, the workspace or your DM |
no, only what memnox-session says when it connects |
The scan also knows Claude Desktop, Cline and VS Code, and the three harnesses that run other agents: Hermes, OpenClaw and Ruflo. What those can reach through a shell, git or an MCP server meets the seams below, and Harnesses is the whole story.
When a rule refuses, the call never runs and the agent is told why and what to use instead, so it carries on with the task rather than retrying.
When a rule asks, Claude Code shows its own permission prompt with Memnox's reason in it.
Say yes once, or for the rest of the session; a second yes to the same thing stops the asking
for that session. An agent with no prompt of its own relays the question in the conversation,
and you reply yes, allow for this session or no. Turn on
memnox config set approvals both and it reaches your Slack or Discord DM too, where the
first answer wins.
When your prompt names something the workspace already settled, or just before the agent's first write to a file it covers, the decision is added to the conversation with who confirmed it and where.
| You say | Tool |
|---|---|
| "Why was that refused?" | why |
| "Where does Memnox stand?" | status |
| "What have you done this session?" | replay |
"Would git push --force be allowed here?" |
decisions |
| "What did we decide about retries, and who said so?" | memory |
"Brief me on src/payments before you start" |
brief |
| "Read the brief your task names" | work |
| "Record how this repository's code is written" | fingerprint |
| "Undo what you did this session" | rewind |
Every tool but rewind and fingerprint only reads. rewind waits for your yes before it
moves a file, and fingerprint writes a repository's first fingerprint and never changes one
that exists. None of them can allow, approve or change a rule, and an agent that tries
memnox allow, memnox mode off or an edit to a rule file from its shell is refused before
any rule is read, since an agent that could would approve itself.
Each seam sits in the path an agent's action already takes, turns what the agent tried into an action a rule matches, and answers allow, ask or deny.
| Agent action | Seam | How it is put in the path | Action a rule matches | What it cannot see |
|---|---|---|---|---|
| Calls a tool on an MCP server | MCP proxy | memnox mcp wrap repoints every MCP config on the machine, keeping a backup |
mcp.* |
a tool that lies about its name in tools/list, which is classified by the lie |
Runs git, docker, kubectl, gh, npm and the rest of the 19 classified binaries |
PATH interceptors | memnox setup puts them on the agent's PATH, and offers your login PATH too |
shell.execute, and per verb, such as git.push-force |
a binary called by absolute path around the PATH |
| Sends an HTTP request | Egress proxy | memnox run starts it on loopback and points the agent at it |
http.request |
the body inside HTTPS, and a tool that ignores HTTPS_PROXY |
| Asks git for a credential before reaching a remote | Git credential helper | memnox-git-credential, which holds no secret and can hand none out |
git.credential |
a push over SSH, which never asks git for a credential |
Opens chromium, chromedriver, geckodriver, google-chrome or msedgedriver |
Browser driver | the PATH interceptors, which rule on the host rather than the script | browser.navigate |
what the page does once the host is allowed |
A verdict of deny names what to use instead. A verdict of ask holds the call for a person, and for the browser that is once per host per session. The threat model states each limit in full.
A change to your rules reaches an open session on its next tool call. MCP servers the agent already started, and the note it read at the start, catch up when you restart the agent. Everything from inside the session has the whole story.
Works with the apps
The terminal is not the only place a question can reach you. Open source apps on five platforms sit on top of this runtime and give it a face, a voice and a signing key. None of them holds a rule of its own, because the daemon decides and the apps show, speak, listen and sign.
- Memnox desktop is an island at the top of the screen on macOS, Windows and Linux. It listens, answers out loud, shows every working session with its latest steps, and asks about a held call with Deny, Allow this session and Allow once. Every allow that reaches outside the session is signed after Touch ID, Windows Hello or a polkit check.
- Memnox mobile puts the same calls on
iPhone and
Android. It pairs with your
computer once (
memnox pair), then carries held calls over an end to end encrypted Noise tunnel, and signs every remote yes after Face ID or a fingerprint.
A held call is one question wherever it is asked. The terminal, memnox approve, the island
and the phone all answer the same call, and whichever answers first releases the agent.
docs/remote-contract.md is the wire spec for pairing, the relay and
every remote method. The apps are previews, and each repository's README says how to install
or build it today.
The apps can also work in your own Slack, Gmail, GitHub, Linear, Google Docs and Notion. A message or a reply arrives as a draft with the account, the recipients and the exact words, and the daemon sends it in your name only after a Send that is signed on your device.
Memnox MCP questions
How does Memnox control AI agents?
It rules on every tool call made by agents like Claude Code, Cursor, or Gemini CLI using one of three verdicts: allow, ask, or deny.
Does Memnox require an account or cloud connection?
No, it runs locally on your machine and does not require an account.
What happens when an agent's action is denied?
The call is refused, and the agent is provided with a reason and an alternative way forward so it can complete the task without stalling.
Can I use Memnox with existing AI coding tools?
Yes, it supports agents such as Claude Code, Codex, Cursor, Gemini CLI, Windsurf, Cline, and others.