developers

agent memory · open on every plan

give your agents the power to remember.

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.

create your innernetread the docs

free to start today, agent memory included, on every plan.

01connect

connect the apps you build with.

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.

cursorconnected

cursor keeps

the conventions in your codebase, and the shortcut you swore you would fix.

claude codeconnected

claude code keeps

how you think a hard problem through, and what you decided together.

codexconnected

codex keeps

the plan it followed, and the step it skipped.

githubconnected

github keeps

what shipped, what was reverted, and why.

chatgptconnected

chatgpt keeps

the bug you described at midnight, and its fix.

linearconnected

linear keeps

what is next, and what keeps slipping to next week.

slackconnected

slack keeps

the decision made in a thread nobody can find.

figmaconnected

figma keeps

the spacing your designer insisted on.

notionconnected

notion keeps

the spec you wrote, and the parts you crossed out.

geminiconnected

gemini keeps

the research you asked for, and the sources you trusted.

copilotconnected

copilot keeps

the completions you take, and the ones you never do.

windsurfconnected

windsurf keeps

the fix it made, and the test it ran after.

cursor kept: retry on reconnect, never on a timerclaude code read it 4 minutes later, in another window

three doors in, one memory.

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/storefrontwhat it prints
~/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
  • Claude Code, Cursor, Codex, Gemini CLI, Windsurf, Zed and more, found and wired in one pass
  • a tool that can only start a command gets innernet mcp, a thin bridge to the same url
  • nothing is stored on your machine: the memory lives at innernet.live

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

and the agents that work for you.

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

your agents remember. you stay in charge.

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

it reaches only as far as you let it.

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

nothing is kept behind anyone’s back.

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.

learned about you · waits for your yes

you prefer email over chat for anything urgent

DELETE …/users/maya31 memories, shown before they go

activity

every answer comes with its reasons.

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.

activity · today

  • brought back 4 for a question about a refundcontext · 37ms

settings

change how it remembers without a deploy.

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.

settings · said in sentences

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.

  • up to 10,000 memories an agent
  • keys and card numbers taken out before anything is kept
  • one memory per person it serves, by user_id
  • plain https, no sdk

see an agent’s page

support desklives in Claude · 215 memories · 38 people
  • how it works 14the steps it follows and the standing orders it keeps.refunds under $40 are approved without asking
  • what it knows 63things that stay true until they change.maya is in lisbon this month
  • what people like 41likes, dislikes and ways of working it was told about.maya likes short answers
  • what happened 88moments it was part of, each with when.sep 27 · a refund for a double charge, settled in one reply
  • notes 9anything else it thought worth keeping.the export is under settings, not the dashboard

what it keeps, on five shelves

04an agent's page

every agent gets a page of its own.

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

six verbs. plain https.

remember, recall, context, forget, export and events. that is the whole api, and each verb says what it may change before you call it.

POST /api/v1/agents/me/memories
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

how you work 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.

storefront · the handoffone channel per project. every write is kept, never overwritten

Claude Code · 20 oct, 6:40 pm

  1. youleave a handoff
  2. innernet innernet_handoff_write

Codex · the next morning, 9:12 am

  1. youwhere did we leave off?
  2. innernet innernet_handoff_readwritten by Claude Code, last night
  3. codexone-page checkout is merged. next is saved carts: a cart should survive a closed tab. migration 0009 runs before the deploy.

the channel

what shipped and what is next, left when a session ends

07git for thinking

your code keeps what changed.
innernet keeps why.

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.

repogithub.com/acme/storefront

7 commits · 13 files · +717 −186 · 1 pr

tuesday 20 october · 3 commits

  1. 5:42 pmc41a9e2merged in #58+200 −146 · 3 files

    Brings one-page-checkout home after a week behind a flag.

    Address, card and confirm on one page. The four-step flow is removed.

    3 files changed · +200 −146

    • src/checkout/Checkout.tsx+142 −38
    • src/checkout/Steps.tsx−96
    • src/checkout/checkout.test.ts+58 −12

    the thinking around it

  2. 3:10 pm4b1d09a+41 −3 · 2 filesone-page-checkout

  3. 11:05 am9e07c3b+44 −11 · 2 files

friday 16 october · 2 commits

  1. 4:20 pmee5d5ca+158 −6 · 2 filesone-page-checkout

  2. 10:02 ama3f8d17+44 −12 · 1 fileinfinite-scroll

tuesday 13 october · 2 commits

  1. 2:30 pm71c2f04+35 −8 · 2 files

  2. 9:12 am1d0b6e8+195 −0 · 4 files

08privacy, for builders

the people your agent serves stay theirs.

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.

  1. 01

    one memory per person

    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
  2. 02

    secrets never land

    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
  3. 03

    forgetting is one call

    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 }
  4. 04

    a key opens one agent

    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
  5. 05

    everything is exportable

    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" }
  6. 06

    no model learns from it

    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.

the whole referenceour privacy policy

09benchmarks and labs

measured, not promised.

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.

  1. tested inside

    netti-1, the person model

    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

    one read
    595 tokens, against 4,052 for retrieval and 59,629 for the whole history
    against the whole history
    0.140 nats a decision better (95% CI 0.122 to 0.157)
    against retrieval
    0.160 nats better on what they choose and what they do next

    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 labs
  2. a benchmark

    likeness-1, the benchmark of person models

    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

    the field
    mem0 open source, Letta Code, Graphiti (Zep’s open-source engine) and Supermemory self-hosted
    where netti-1 holds
    what they choose, what they do next, what they mean, what changed and when it changed
    the run
    40 people, read by Claude Haiku 5.5, counted with Holm’s correction

    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 labs
  3. a paper

    the infinite window

    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%

    LongMemEval-S
    6,675 task tokens a question against 173,198, on 100 held-out questions read by Claude Haiku 5.5
    one ask
    $0.00083 against $0.0870
    too few memories
    at k=10, 81.0%: it starts losing answers

    where it lost on LoCoMo, with the whole conversation kept in cache: 73.3% against 87.8%, the window lost.

    the infinite window, in labs

on 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

you only pay when netti thinks.

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

innernet

free forever

the whole product, agent memory included.

netti’s folds, a month200

reading never counts, from any ai or any agent.

  • the entire product, nothing held back
  • 200 folds a month: you are only counted when netti thinks
  • reading is free forever, even past the folds
  • no card, no clock, no expiry

cancel anytime

innernet plus

$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.

  • unlimited folds: netti thinks as much as your memory needs
  • the deeper agent passes: heavier consolidation, sharper recall
  • every feature we ship next, the day it ships
  • a straight line to the people who built it

what is a fold?

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.

this month · 37 of 200 folds

every innernet, at any price

  • one memory across every ai: claude, chatgpt, cursor, anything that speaks mcp
  • personal memory that learns how you work, not just what you saved
  • project context maps the agent keeps current on its own
  • versioned thinking: commits, branches, directions parked and merged back
  • living artifacts that reorganise themselves as findings land
  • an activity feed that narrates what was learned, written to be read
  • import your scattered claude and chatgpt history in one pass
  • private by default: row-level security, export or delete anytime
  • memory for the agents you build: up to 100 agents, each keeping 10,000 memories about the people it serves

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

the short answers.

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

your agents remember.
you decide.

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.

innernet.live/skills/agent-memory/raw

free to start today, agent memory included, on every plan.