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 links the repo to its memory. It installs the git hooks and writes the MCP config, then steps out of the way:

bash

npx innernet connect

That's the whole setup. connect links this repository to an innernet project, drops a committed .innernet anchor at the root, installs the post-commit / pre-push hooks, and registers the hosted MCP endpoint with whatever AI clients it finds. From then on, innernet follows the project — across machines, across sessions, across tools.

ambient on git#

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

Every commit is captured. The post-commit hook lands the diff context and message as a fast capture — no prompt, no friction, no flow broken.
Every push consolidates. The pre-push hook folds the captures since the last push into the project's dimensions — at the right frequency, not on every keystroke and not so rarely it forgets.

The two-loop rhythm matches how you actually work: capture is cheap and immediate, consolidation is careful and batched. Memory that rides on git means the record stays current because you're shipping, not in spite of it.

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 connect writes that for you. 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#

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

Because it's committed, the link travels with the repo. A teammate clones, runs npx innernet connect, 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 new teammates start 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, instead of "resolved" by whichever note was written last.