for developers

Memory that versions with your code. innernet rides along on the work you already do — every commit captured, every push consolidated — so the context behind your codebase never goes stale. Connect once, and it follows the project.

connect once#

One command, and every AI tool on your machine shares one memory:

bash

npx innernet

That's the whole setup. It signs you in to innernet.live once, then wires every AI tool it finds on the machine — Claude Code, Cursor, Codex, Windsurf, Gemini CLI, Claude Desktop, VS Code, Cline, Zed, OpenCode — to the hosted MCP endpoint. Run it inside a repo and that folder gets a memory of its own: netti reads the README and the file tree and designs the memory's shape from what the project actually is, then drops a small committed .innernet anchor so the link travels with the repo. Re-running is always safe.

Nothing runs a model on your machine and there is no local copy to keep in sync. Every tool reads and writes the same memory, and netti keeps it current.

ambient on git#

You don't run innernet. It runs on your commits.

Every commit is captured. npx innernet installs one post-commit hook that lands the commit message and diffstat as a capture — no prompt, no friction, backgrounded so it can never slow a commit.
netti folds it in. Consolidation happens on the server, when it should — not on every keystroke and not so rarely it forgets. The captures since last time get folded into the project's dimensions; the body of each dimension describes the present, and a ## history line records what it superseded.

MCP-native#

innernet speaks MCP (Model Context Protocol). Every MCP-aware editor reads the same project memory live — Claude Code, Cursor, Cline, Zed, and anything else that speaks the protocol. One endpoint, one config:

text

https://innernet.live/api/mcp

Drop this into any client's MCP config:

json

{
  "mcpServers": {
    "innernet": {
      "url": "https://innernet.live/api/mcp",
      "transport": "http"
    }
  }
}

npx innernet writes that for you (with your key, so nothing has to sign in again). Or wire it by hand — Claude Code is a one-liner:

bash

claude mcp add --transport http innernet https://innernet.live/api/mcp

On first use the client opens a browser sign-in (OAuth 2.1); you approve once and it holds a scoped token from then on. You never paste a key into a chat. Per-client walkthroughs live in Connect an AI.

the `.innernet` anchor#

npx innernet commits a small .innernet/connection.json to the repo root. That file is the tie between this codebase and its memory — it records the project slug, nothing secret.

Because it's committed, the link travels with the repo. A teammate you've shared the memory with (a room) clones, runs npx innernet, and inherits the same context map — same dimensions, same decision log, same branchable history. No onboarding doc to read, no tribal knowledge to transfer. The repo carries its own memory.

git for thinking#

Your context map is versioned the way your code is:

Commits — every save and capture is an append-only entry with a message and a trigger. You can read what changed, when, and why.
Branches — fork the whole context map to explore a divergent direction — a different architecture, an alternative API shape — without disturbing trunk. Diff it, then merge it back when the direction wins.
Inherited on clone — the .innernet anchor means a teammate you've shared the memory with starts from the full, current picture instead of an empty mental model.

This is the part flat memory tools can't do: two contradictory versions of a design held in tension on purpose, on branches, instead of "resolved" by whichever note was written last.

On trunk the opposite rule holds, and it matters just as much: a dimension body describes the present. When a decision supersedes an earlier one, netti replaces it and records a dated line under that dimension's ## history — so a session six months from now reads what is true today, and can still find out how it got that way. Divergence lives on branches; the trunk stays unambiguous.