cursor keeps
the conventions in your codebase, and the shortcut you swore you would fix.
agent memory · open on every plan
your agents are 1% of the work. the other 99% is you, and today every agent forgets it. innernet is the one memory they all start from.
01connect
each tool you build with knows one part of the work and nothing of the rest, so you explain it again in every one. connect them once, and they all read and write the same memory.
cursor keeps
the conventions in your codebase, and the shortcut you swore you would fix.
claude code keeps
how you think a hard problem through, and what you decided together.
codex keeps
the plan it followed, and the step it skipped.
github keeps
what shipped, what was reverted, and why.
chatgpt keeps
the bug you described at midnight, and its fix.
linear keeps
what is next, and what keeps slipping to next week.
slack keeps
the decision made in a thread nobody can find.
figma keeps
the spacing your designer insisted on.
notion keeps
the spec you wrote, and the parts you crossed out.
gemini keeps
the research you asked for, and the sources you trusted.
copilot keeps
the completions you take, and the ones you never do.
windsurf keeps
the fix it made, and the test it ran after.
wire your machine with one command, point any mcp client at one url, or call your own memory over plain https.
43 tools over mcp, 86 routes over rest. every tool has its twin, and a test fails the build if one goes missing.
~/code/storefront $ npx innernet innernet one memory for every ai tool you use 1 · sign in ✓ signed in 2 · your ai tools → innernet.live/api/mcp ✓ Claude Code claude mcp (user scope) ✓ Cursor ~/.cursor/mcp.json ✓ Codex CLI ~/.codex/config.toml 3 · this folder ~/code/storefront ✓ memory storefront started, with pages netti keeps current ✓ AGENTS.md tells every coding agent where it lives ✓ every commit here is kept, with its message
for your own machine, and the repo you are in.
it signs you in, points every ai tool it finds here at the same memory, and gives this repo a memory of its own. from then on, every commit is kept with its reason.
02agent memory
your agent forgets each person the moment the chat ends. paste two things into the ai you code with: it adds two calls to your code, and from the next turn your agent remembers everyone it serves.
1the block
2your agent keya sample
paste both into Claude Code, Cursor or Codex. it keeps the key in INNERNET_AGENT_KEY, adds the two calls, and shows you it works. your own key is made in your dashboard, under agents.
app/api/chat/route.ts
export async function POST(req: Request) { const { message, userId } = await req.json()+ const memory = await remembered(message, userId) const reply = await model.answer({- system: PROMPT,+ system: `${PROMPT}\n\nwhat you remember:\n${memory}`, message, })+ keep(message, reply, userId) return Response.json({ reply }) }
your ai read the block, found the turn, put the key in INNERNET_AGENT_KEY, and added two calls. nothing else changed.
03why it matters
an agent that remembers is only safe to hand real work if you can see and change what it remembers. every agent you make comes with four controls, and none of them needs code.
access
every agent gets one level for your own memory. the support bot can stay sealed while your coding agent reads how you like to work.
it reads what any app may, and anything it learns about you waits for your yes.
control
what an agent learns about you waits for your yes. and for the people it serves, one call forgets a person entirely, after showing exactly what goes.
you prefer email over chat for anything urgent
DELETE …/users/maya31 memories, shown before they go
activity
every read and every write is on the record. when someone asks why your agent said that, you can show them what it remembered, and when.
settings
what it keeps, what it forgets and what it brings back are sentences on its page. change one, and the next turn already follows it.
it forgets a moment after . a fact stays until it changes.
it brings back up to 10 memories for a question, the newer ones a little ahead.
what it keeps, on five shelves
04an agent's page
see what it keeps, what it may read of you, everything it did and how it remembers, and change any of it without touching code.
a new agent starts at asks first: anything it learns about you waits until you keep it or let it go.
05the api
remember, recall, context, forget, export and events. that is the whole api, and each verb says what it may change before you call it.
requestPOST /v1/agents/me/memories
{ "messages": [
{ "role": "user", "content": "short answers please. i'm in lisbon this month." },
{ "role": "assistant", "content": "noted." } ],
"user_id": "maya" }answer{ "memories": [
{ "content": "maya likes short answers", "kind": "preference", "user_id": "maya" },
{ "content": "maya is in lisbon this month", "kind": "fact", "user_id": "maya" } ],
"about_you": [], "skipped": [],
"redactions": { "emails": 0, "phones": 0, "secrets": 0, "cards": 0 } }hand it a turn. it hides secrets, keeps what is worth keeping as separate memories, merges what it already knew, and offers you what is about you.
on mcp, for your own memory: innernet_capture readOnlyHint: false · destructiveHint: false
an agent key reaches its own agent and nothing else of yours: me is whichever agent the key belongs to. the whole reference is at docs / agents api.
06working with innernet
switch tools mid-task and the new one starts blind. with innernet it picks up where the last one stopped. four pieces carry the work: the handoff, one AGENTS.md, the repo's .innernet, and the rules every client is handed.
say “leave a handoff” when you stop, and “where did we leave off?” when you start. the next session can be in any tool, on any machine.
Claude Code · 20 oct, 6:40 pm
innernet innernet_handoff_writeCodex · the next morning, 9:12 am
innernet innernet_handoff_readwritten by Claude Code, last nightthe channel
what shipped and what is next, left when a session ends
07git for thinking
every commit arrives with the decision behind it, the chat it was made in and the handoff that came next, so months later you still know why. open one.
an agent can think on a branch of its own memory too: read its diff, then merge it or let it go. main never sees a guess.
7 commits · 13 files · +717 −186 · 1 pr
tuesday 20 october · 3 commits
friday 16 october · 2 commits
tuesday 13 october · 2 commits
08privacy, for builders
when someone asks what your agent knows about them, you can show them, and forget it in one call. six rules hold for every agent, each one a call you can make.
01
every call carries the person's user_id. one person's history never reaches another person's answer.
POST /api/v1/agents/me/context{ "query": "where is my order?", "user_id": "maya" } → maya's memories, and only hers dev's never reach maya's answer, or the other way
02
keys and card numbers are taken out before anything is stored, hashed or shown to a model. emails and phone numbers too, when you switch them on.
POST /api/v1/agents/me/memories{ "content": "refund it to 4242 4242 4242 4242" } → kept: "refund it to [card]" a pasted api key becomes [secret] the same way what is taken out is gone for good
03
a dry run says exactly what would go. then one call forgets a person entirely, every memory and every version.
POST /api/v1/agents/me/forget{ "filters": { "user_id": "maya" }, "dry_run": true }→ { "forgot": 31, "dry_run": true } DELETE /api/v1/agents/me/users/maya→ { "ok": true, "forgot": 31 }
04
an agent key reaches its own agent's memory and nothing else of yours: never another agent, never your projects.
GET /api/v1/agents/me/recallAuthorization: Bearer $INNERNET_AGENT_KEY → me is the agent this key belongs to never another agent, never your projects
05
every memory an agent keeps, as json, whenever you ask. yours to keep, move or check.
GET /api/v1/agents/me/export → { "agent": { … }, "memories": [ … 215 ], "exported_at": "2026-10-20T09:14:02Z" }
06
what your agents keep never trains a third-party model, and we never train our own on identifiable memory.
# innernet.live/privacy we do not use your memory or inference inputsand outputs to train third-party models.
09benchmarks and labs
every memory says it remembers. we measure ours: whether it knows the person, what a turn costs, and where it loses. three lines of research, each with its numbers.
tested inside
an agent that needs to know someone is handed their whole history, or a few snippets that match the words. netti-1 hands it the person: what they mean, what they will choose, what changed.
84.6×fewer tokens than the whole history, and a better read of the person
where it lost two guardrails failed, and the paper says so: a forget left its words in a cache, and the packet made the reader agree a little more often with a belief that was checkably wrong.
the person model, in labsa benchmark
recall tests stopped telling memories apart: 6 of the 8 scores vendors report on LongMemEval sit between 90 and 95. likeness asks whether a memory knows the person it belongs to, scored against what could be known, with no judge.
5 of 10kinds of question where netti-1 reads the person better than all four engines
where it lost the other way, mem0 open source leads on what weighs more and Graphiti (Zep’s open-source engine) leads on no false insight. and only on what they mean does netti-1 also beat a simple model of the person’s own past.
the board, in labsa paper
an agent that keeps the whole history in its context pays for all of it on every turn. the window fills a bounded context from memory on each turn instead.
25.9×fewer tokens a question than the whole history, at the same 90.0%
where it lost on LoCoMo, with the whole conversation kept in cache: 73.3% against 87.8%, the window lost.
the infinite window, in labson LongMemEval-S, the usual recall test, innernet’s agent memory answers 89.4% of all 500 questions on its own production code, and 89.4% of the 350 tuning never saw (with netti-1, which every innernet runs on). every benchmark we run
10pricing
every plan is the whole product, agent memory included, and reading is always free. the only difference is how much netti thinks for you: 200 folds a month free, unlimited on plus, and plus gets what we ship next, first.
no card required
free forever
the whole product, agent memory included.
netti’s folds, a month200
reading never counts, from any ai or any agent.
cancel anytime
$14 a month
the same product with no limit on netti’s folds, and what we ship next, first.
netti’s folds, a monthunlimited
no ceiling, for a memory that moves every day.
a fold is one pass of netti filing what was kept, by you or by an agent, into the right page. reading is free, so only the last of these counts.
on every plan, from the first minute, agent memory included.
a price for teams and products that run many agents is not set yet. if it ever changes what you pay, you will hear it from us first, with time to decide.
questions
two calls a turn. before it answers, POST /agents/me/context with the person's user_id and their message, and put what comes back in the prompt. after the reply has gone out, POST /agents/me/memories with the exchange, and innernet decides what is worth keeping. recall, forget, export and events are there when you need them.
no. innernet decides what is worth keeping, sorts it by what kind of thing it is, labels who it is about, versions it, and forgets on the schedule you set. recall ranks by words, recency and importance, and can re-read the best matches by meaning.
any. it is plain https and json, so it fits whatever your agent is written in and whichever model it runs on. the sorting happens on innernet's side, so your agent makes no extra model calls of its own.
up to 100 agents on one account, each keeping 10,000 memories about the people it serves. what happened once fades after 90 days, and facts and how-tos stay until you forget them; both are settings. by default an agent writes up to 120 times a minute and reads up to 600.
reading never counts: context and recall are free on every plan. only a fold counts, one pass of netti filing what was kept, and an agent's keep is a fold like yours: 200 a month free, and as many as you need on plus, at $14 a month.
the mcp server and /v1 are your own memory, for the ai tools you use. an agent's memory is its own, kept per agent and per person it serves, and it reaches yours only as far as you allow.
the person who keeps the agent. it lives in innernet's database, answering only to that account, enforced in the database itself. export is one call, and an agent removed takes its memory with it.
today. create your innernet, connect the tools you build with, and paste the block on this page into the agent: it remembers from its first call.
agent memory
paste the block into your ai, and your agent remembers from its next turn. innernet works from the first minute, and so does everything you connect to it.
free to start today, agent memory included, on every plan.