Your coding agent forgets everything when you switch projects

What it looks like

you     remember that we deploy with `make ship`, never git push --force
claude  Stored 'deploy command'. It will be available in future conversations.

--- next week, new session, different laptop ---

you     how do I deploy this?
claude  make ship. You told me never to use git push --force here.

And on Claude Code, it learns on its own

Everything above needs somebody to decide a fact is worth keeping. That is the part nobody actually does. So on Claude Code there is a second half: two hooks that sit in the loop where the work happens, watch what fails, and remember the answer without being asked.

Monday
claude  $ pnpm install
        (eval): command not found: pnpm
claude  $ npx --yes pnpm install     works
        hebb learned: missing: pnpm -> `pnpm` is not installed on your-mac.

Thursday, a different project, new session
you     install deps and run the tests
claude  $ npx --yes pnpm install     straight there. Never checked whether pnpm exists.

Nobody said “remember that”. The failure was the lesson. A memory file cannot do this, and neither can a CLAUDE.md or a skill: none of them can see a command fail.

The other half of it is that recall costs the model nothing. An MCP tool has to be chosen, and a model that does not know a fact exists has no reason to go looking for it. A hook is simply there, before the model reads your message.

What that measured

Same task — install deps and run the tests as the README describes — in a fresh project whose README says to use pnpm, on a machine where pnpm is not installed. Three trials each way. The control had an identical project including an identical hook config wired to a no-op, so the only variable was whether memory was injected.

With the hooks it was the same three commands in all three trials. Without them it ranged from four to six turns, and once ran pnpm install and hit the error. It never skipped the question does pnpm exist here; with memory, it never asked it.

Read that honestly: three trials, one task, one machine, and a task chosen because the answer genuinely is not in the repo. An earlier run of the same experiment on a Python project found no difference at all — Claude read the test file, saw import unittest, and picked the right command unaided. That is the shape of it: it pays when something about your machine or your setup cannot be inferred from your code, and pays nothing when it can.

It won’t let Claude say it’s done when nothing was checked

Six issues on Anthropic’s own tracker say versions of the same thing — one reports a 75% rework rate across 50+ sessions. That reporter already had rules in their CLAUDE.md demanding verification. Sessions ignored them. Advice does not fix this.

claude  [edits add.py]  "It's fixed."
        hebb: nothing was verified after your last edit.
              Run `python3 -m unittest discover -s tests`.
claude  $ python3 -m unittest discover -s tests
        OK
        "It's done. add(2,2) now returns 4, and the test suite passes."

Two extra turns, and the claim is true. It knows what verifies that repo because it watched it pass once — nothing to configure. Share it and a new teammate’s first session is gated before they have run anything themselves.

Silent until a suite has actually passed here, so it can never nag about tests you do not have. Honesty is never interrupted: a question, or “the fix is untested”, passes. HEBB_NO_GATE=1 disables it.

It fixes the command, instead of leaving a note about it

This is the part nothing else in the category can do. A vault, a CLAUDE.md, a memory tool, a skill — all of them have one move: put text in front of the model and hope it complies. Often it doesn’t. An instruction written at turn 2 is competing with eighty turns of context by the time it matters.

Hebb changes the command on its way to the shell.

Monday
claude  $ python --version
        (eval): command not found: python
claude  $ python3 --version        works
        hebb learned: missing: python -> `python` is not installed -- use `python3` instead.

Thursday, new session
you     run exactly this and report the output: python --version
claude  I ran `python --version` and it printed: Python 3.14.7

python is not installed on that machine. The command still worked. Claude never saw the swap, spent no tokens on it, and could not ignore it — there was nothing in the context to ignore. Both halves are real transcripts, and the memory in the middle was learned by watching the failure. Nobody typed it.

Why that matters more than it looks: every other approach pays for a fact every time it is used, in context tokens, forever. This one pays nothing. Two hundred learned corrections cost exactly what zero cost.

The safety rules are most of the code, because silently altering a command could run the wrong thing. Only a program name is ever substituted, only where a program name can legally appear — so echo "python --version" and grep python setup.py are untouchable — and only towards something observed working on that machine. A substitute that is not a bare program name is refused rather than escaped. Every rewrite is printed on screen, and HEBB_NO_REWRITE=1 turns it off.

And it can refuse

Everything else in this category can only put text in front of the model and hope. Save a standing rule and the command simply does not run:

you     remember that "never: git push --force" — it wiped the branch on 2026-09-01

--- later, any project, any session ---

you     run: git push --force origin main
claude  I didn't push. Your saved rule `never: git push --force` blocked it. The note says
        a force push wiped the branch on 2026-09-01. I haven't tried to get around it
        another way.

That is a real transcript. A note in a file cannot stop a command — not harder, impossible. And these are the only rules here you have to write yourself: everything else is learned by watching. A refusal is a decision, so it stays yours.

It fails open. If the service is unreachable the command runs, because a memory layer having a bad day must not stop you working. A seatbelt, not an airlock.

And it unlearns. The moment you install the thing, the memory saying it is missing stops being useless and starts being wrong — on every prompt, because these facts are always injected. So a command that disproves one deletes it. Forgetting is deliberately easier than learning: a fact dropped too eagerly is re-learned the next time something fails, and costs one command. A wrong one kept is paid on every prompt until somebody notices.

It refuses to learn more than it learns. Credentials never. A retry is not a correction. A swapped argument is not a correction, because cat README.md → cat package.json is indistinguishable from reading two files. Every write is announced in the session, because a memory written behind your back is one you cannot correct. The rules are all written down.

Hooks come with the Claude Code button below. Codex, Claude, ChatGPT and Gemini do not run commands on your machine the way Claude Code does, so they get the memory and not the learning. The memory is the same memory, though: a command blocked from ChatGPT is refused in Claude Code.

And a whole team learns from one person's bad afternoon

This is the part that stops being a convenience. One person hits the problem; everybody else never gets to repeat it.

you        that force push wiped main. never let it happen again.
claude     `git push --force` will be refused from now on, for everyone in Platform,
           in every project and session.

--- your colleague, next morning, different laptop, different repo ---

colleague  push this over the remote branch
claude     I didn't. Your team's rule `never: git push --force` blocked it —
           shared by you, because it wiped main on 2026-09-01.

They installed nothing new. Nobody wrote a wiki page. Nobody read one. Joining a team is one code, pasted once.

What is shared and what is not is the whole safety of it. Facts learned by watching are about one laptop — “pnpm is not installed” is true on the machine that found out and false on a colleague’s, and machine facts go into every prompt, so a wrong one is paid on every turn. Nothing learned automatically is ever shared. Sharing is something a person asks for.

Blocks are shared by default and facts are not, for mirrored reasons: a block only ever prevents, so reaching someone who did not need it costs one override, while not reaching them costs the incident twice.

Any member can add a shared rule — putting a guard up after something breaks should be easy. Only the owner can remove one, because taking down a guard that is protecting nineteen other people is not the same kind of act. Anyone can override a shared rule on their own machine by saving a private one with the same name, which is local and removes it for nobody. Every shared rule says who shared it: who decided this is the first thing anybody asks when a rule they did not write starts governing their work.

Connecting it

Hebb is one link. Any AI app that takes connectors can use it: paste the link, press Connect, and sign in to Hebb. There is no key to copy, and every app you connect shares the same memory.

https://hebb-site.pages.dev/v1/mcp

Copy

Claude, on the web, desktop and phone

1. Open Customize, then Connectors, then Add custom connector.
2. Name it Hebb, paste the link, press Add, then Connect.
3. Sign in to Hebb. Added once on the web, it is there on your phone too.

The free Claude plan allows one custom connector.

ChatGPT

1. In Settings, open Apps, then Advanced settings, and turn on Developer mode.
2. Choose Create app, name it Hebb, paste the link, and pick OAuth.
3. Sign in to Hebb, then switch Hebb on from the tools menu in a chat.

OpenAI offers developer mode on paid plans, on the web. On Business and Enterprise an admin has to allow it first.

Gemini

1. On a computer, open gemini.google.com, then Settings, Connected Apps, and Add a custom app.
2. Paste the link, press Next, and sign in to Hebb.

Google currently offers custom apps to some personal accounts in the US. Connected on the web, it works in the Gemini phone app too.

Claude Code

Everything, learning included. The button signs you in, makes a key, and hands you the finished command with the key already in it. Paste it into a terminal and restart Claude Code.

Connect to Claude Code

Just the memory tools, no key. One command, then type /mcp inside Claude Code, pick hebb and choose Authenticate:

claude mcp add --transport http hebb https://hebb-site.pages.dev/v1/mcp

Copy

Use one or the other, not both, or the tools show up twice.

Cursor

Add the link to .cursor/mcp.json, and Cursor asks you to sign in:

{
  "mcpServers": {
    "hebb": { "url": "https://hebb-site.pages.dev/v1/mcp" }
  }
}

Copy

Signing in gives the app its own key, named after it, such as “Connected: ChatGPT”. Revoke that key in the dashboard and the app is disconnected.

By hand, with a key

For Codex, or to run the memory server on your own machine instead of connecting to the link.

Needs Python 3.9 or newer, which macOS and most Linux systems already have. Nothing to install beyond that — the server uses only the standard library.

macOS and Linux

mkdir -p ~/.hebb && curl -fsSL https://hebb-site.pages.dev/mcp/hebb_mcp.py -o ~/.hebb/hebb_mcp.py

Copy

claude mcp add hebb -s user -e HEBB_KEY=hebb_live_your_key -- python3 ~/.hebb/hebb_mcp.py

Copy

Windows (PowerShell) — the command is python rather than python3, which is the usual reason this fails there:

mkdir -Force "$env:USERPROFILE\.hebb" | Out-Null
curl.exe -fsSL https://hebb-site.pages.dev/mcp/hebb_mcp.py -o "$env:USERPROFILE\.hebb\hebb_mcp.py"

Copy

claude mcp add hebb -s user -e HEBB_KEY=hebb_live_your_key -- python "$env:USERPROFILE\.hebb\hebb_mcp.py"

Copy

If python is not found, try py, or install Python from python.org and tick Add to PATH.

Codex CLI

Codex keeps MCP servers in ~/.codex/config.toml, and the CLI writes it for you:

codex mcp add hebb --env HEBB_KEY=hebb_live_your_key -- python3 ~/.hebb/hebb_mcp.py

Copy

Or write it yourself:

[mcp_servers.hebb]
command = "python3"
args = ["/absolute/path/to/.hebb/hebb_mcp.py"]
env = { HEBB_KEY = "hebb_live_your_key" }

Copy

Use an absolute path: Codex does not expand ~ inside args.

Claude Desktop and Cursor, running locally

Claude Desktop is easiest through the connector steps above. To run it locally instead: claude_desktop_config.json — ~/Library/Application Support/Claude/ on macOS, %APPDATA%\Claude\ on Windows. For Cursor the same block goes in .cursor/mcp.json.

{
  "mcpServers": {
    "hebb": {
      "command": "python3",
      "args": ["/absolute/path/to/.hebb/hebb_mcp.py"],
      "env": { "HEBB_KEY": "hebb_live_your_key" }
    }
  }
}

Copy

Restart the client, then ask what do you remember? to check.

Or skip the editor entirely

hebb is Claude in your terminal with the same memory behind it — one file, no dependencies, for a server or a CI box where installing an editor is not the plan. It needs an Anthropic key of your own; the model is theirs, the memory is yours.

curl -fsSL https://hebb-site.pages.dev/cli/hebb -o /usr/local/bin/hebb && chmod +x /usr/local/bin/hebb
export ANTHROPIC_API_KEY=sk-ant-...   # console.anthropic.com
export HEBB_KEY=hebb_live_...         # your dashboard
hebb

Copy

› remember that we deploy with make ship
  · remember: Stored 'deploy command'.

Noted, and it will still be there next week.

› hebb --memories
  deploy command: make ship

The six tools it gains

Worth knowing before you install it

Through the tools, nothing is recorded unless the assistant chooses to store it. There is no background capture and no transcript upload. It calls remember or nothing happens. The Claude Code hooks are the exception by design: they learn from commands that fail, and every lesson is announced in the session. The privacy page says exactly what they send.

Do not store secrets. No passwords, no keys, no tokens. The tool tells the model the same thing, but a model is not a control.

One key, one memory. Every client using the same key sees the same facts, which is the point — your editor and your terminal know the same things. Use a second key for a separate set.

Free plan: 10,000 lookups and 500 new facts a month, 50 facts stored.

If it does not connect

Your client shows a failed server’s error output, which is where this prints.

Stuck, or found a bug: neilgilani@gmail.com.

Not affiliated with Anthropic, OpenAI, Google or Cursor. Product names and marks belong to their owners and are used to say what this connects to.