Skip to content
Kapi

Kapi Memory · the memory layer

AI conquered compute. Memory is still on the human side.

Every model answers from a blank page. What you decided last month, what has changed since, how you like a thing done: that lives in you, and you type it into every prompt again. Kapi is the layer underneath. Memory that is kept on your machine, distilled while you are away, and, soon, served to every AI you use.

Kapi Dream, for youKapital, for your team
The store stays on your machine — a model sees one turn's context, never the store
The modelsOUTSIDEthey answer, and do the background workeach call carries one turn's context, never the storeKapi's gatewayOURSit keeps counts, never wordsChatassembledfrommemoryMemoryeveryshelfQueuewhatitasksyouThreadsyourloopsCalendaryourdaysThe engineYOURSit assembles each promptkeeps what you stateand runs the passesOne database, yoursON THIS MACHINEthe record · episodes · facts · loops · questions ·self-checksTHE EDGE OF YOUR MACHINETHE MODEL PROVIDERSour serverYOUR MACHINEDISTILLafter every turn

The idea

Intelligence is memory and compute. We solved half.

Compute is a commodity now. Models reason, context windows run to millions of tokens, and the price per token falls every quarter. And still every agent starts cold.

It does not know you. It does not know yesterday. It hauls the same sheets into context at every turn, whether the moment needs them or not, and when a fact changes it holds three versions of it at once. The memory is still on the human side: in your head, in your habit of re-explaining, in the forty lines you paste before you can ask the question.

Our bet is that agents, and the people who use them, fail without the right memory no matter how good the models get. Tokens per task are the unit economics of working with AI. Memory is the largest recurring line in every prompt, usage per task grows faster than price falls, and the wait before the first word is physics, not pricing. The falsifier is honest: if a frontier model given brute-force context matches a memory-built system on recall per token, the bet is lost. We will publish the measurement either way.

So Kapi is not a feature of a chat app. It is infrastructure: one memory core that serves one person's whole life and many agents' shared work, two owners with opposite needs. A thing that serves both is a foundation, not a plug-in.

A model alone, and a model with memory
A model aloneEVERY TURN FROM ZERO×knows nothing of you until you type it×re-reads the same sheets into context, whetherthe moment needs them or not×three conflicting versions of a fact thatchanged·the context window grows; the bill and the waitgrow with itA model with memoryTHE RIGHT MEMORY+what you stated, kept at once; what changed,superseded+an episode reloads whole only when it is named+the current answer, with the old one kept forthe record+fewer tokens per task, and the same tokens nextweekVSThe yardstick for every decision — the right memory, at the right time, for the fewest tokens.
Memory is the treasury and guardian of all things.Cicero

Memory, not knowledge

Knowledge is what is true in the world. Memory is what happened to you.

Knowledge management indexes artifacts. Memory distills thinking. The two are confused daily, and the confusion is why every memory product so far has been a search box.

A document is the same for everyone who reads it. A memory is not: it belongs to one person or one team, it carries who said it and when, it has tense, and it can be wrong. You correct a memory; you do not correct an index. A memory changes its mind when you do, and it forgets on purpose, because a store that only grows is a landfill with a search bar.

The hard part is surfacing, not storing. Storage was solved long ago; anyone can persist everything. People are the opposite of machines here: from a lifetime of experience they surface exactly the right memory at the right moment, at almost no cost. That is the ability Kapi is built to give an AI.

And the raw material is new. Every product in this space ingests where decisions are announced: meetings, chat, email, documents. AI conversations are where decisions get made, and nobody mines them. They sit scattered across each person's assistants. Thirty million tokens of conversation becoming a few hundred kilobytes of what lasts: that compression is the product.

Memory is how a system acts on past experience. It is not a retrieval score.the canon · why memory is the product
Knowledge and memory are different in kind
KnowledgeMemory
What it holdsartifacts — documents, pages, ticketsexperiencewhat was said, decided, tried, and how it went
Whose it iseveryone's; true in the worldyourssituated — this person, this team
How it is foundsearch, by similarityby kinda fact by its slot, an episode by its name, a rule always
Timea timestamptwo clockswhen it happened, and when it was said
When it is wrongthe index is rebuilta questionto the person — never a silent overwrite
Over the yearsit accumulatesit settlesconsolidates, supersedes, retires — and forgets on purpose

The kinds of memory

One store, many kinds of remembering.

Every system that reduces to a vector database with an API fails the same way: it can write and search, but it cannot tell kinds of remembering apart, and it cannot change its mind.

Kapi's memory is a manager, not a store. A kind is defined by how a memory is born, how it is kept and how it leaves, never by its topic. A fact is superseded, never edited. An episode retires by distance and wakes when named. A rule you gave never fades. An open item lapses with its reason. A procedure is performed, not summarised. No kind borrows another's verbs, because summarising a procedure or fading a rule is a category error, and a single-verb system is forced into exactly those errors.

The shelves follow a person, not a database. Eight of them, separated by tense: a memory's relation to time. Topic is never a shelf.

Forgetting is a feature. Lossy, constantly overwritten and always current beats complete and stale. There are six words for gone, with one meaning each, and only the person does the last.

dormantset aside for disuse; it wakes on recall
retiredno longer live, kept for the record
supersededreplaced by a later memory that points at it
lapsedan open item that left by distance
redactedits words went with an erased chat; the row stays
erasedgone — only you do this
The eight shelves, by tense — topic is never a shelf
Who I amBUILTtimeless — only the person states it; never read out of behaviourWhat isBUILTpresent — first mention, accumulates; goes dormant when untouchedWhat happenedBUILTpast, closed — the episodes; retire by distanceWhat I concludedBUILTsettled — rulings, decisions, reflections, thesesWhat I am doingBUILTongoing — pieces of work; completed is a state, keptWhat is outstandingBUILTpending — open items, commitments, things for laterWhere I am goingDECLAREDintended — a plan, authored, never extractedHow I do itBUILThabitual — procedures; a new method supersedes the old
A kind is a contract — how it is born, how it leaves
KindBornLeaves
factcompaction extracts it, or the person says itsuperseded, retired, or dormant until recalled
episodethe first pass, never at write timeretires by distance; wakes when named
decisionthe person chooses and says so — never read out of behavioura later decision, or the person retires it
rulethe person states it, or one repeats — never a passing remarknever fadesthe person retires or replaces it
procedurethe person describes a method, or a pass reads one outthe person changes the method
open itemwhat was left hanging — a question, a promiseresolved, or lapses with its reason
reminder"later", with enough for a dateraised once, inside its window, or expires
reflectiona pattern across three or more pieces of workasked firstwithdrawn unless the person says yes
gapwhat is missing that has already cost somethinganswered — kept for the record

The dream

Memory works while you are away.

Capture is per turn, and consolidation never is. What you state is kept at once. Everything heavier runs after the reply, off the path you are waiting on, and a reply never waits for memory.

After a turn, the passes read the settled part of a chat into facts and episodes, fold narrow episodes that turned out to be one job, regenerate summaries from the record rather than from the last summary, ask the self-checks earlier passes wrote, and let quiet facts rest. Once a week, when a week has passed and enough is new, the look-back runs across everything known about you: which newer fact replaced which older one, what has stopped mattering, a pattern in how you work, what is missing that has already cost you something, and which pieces of work recur. That is the dream, and the product for one person is named for it.

  1. Nothing runs inside your turn. The passes start after the reply; if they fall behind, they catch up.
  2. They wake on substance, not on a timer. A quiet week costs nothing.
  3. None deletes or rewrites what you said. Reversing something you stated comes to you as a question. Setting a fact aside can be undone.
  4. One job each. Every pass asks a model one question, never two at once.
  5. Every pass is logged, with its cost. The log records what changed, never your words.
Two rhythms — after a turn, and once a week when enough is new
Open itemsevery turnCompactionlong chatsConsolidateone jobSummariesfrom the recordSelf-checkstill answered?Evictionquiet facts restAfter aturnPER CHATReconcileasks you firstRetireundoableReflecta patternGapswhat is missingPieces of workacross chatsThelook-backONCE A WEEKevery passon the log
Compaction — the settled part of a chat becomes facts, episodes and self-checks
Cutjustbefore oneof yourmessagessettled turnsReadthesettledpart, inone callcandidatesFactscheckedagainstwhat isbelievedkeptEpisodesfiled bytopicfiledSelf-checksquestionsit muststillanswerA CHATTHAT HASGROWNLONGTHE LIVEPARTshorterwith whatis stillopen

Every level

Yours, your team's, your company's.

The same ladder of scopes runs through everything Kapi will build: me, then team or project, then company. Memberships say who is in which group, for a person's memory and a team's board alike.

Your own memory stays on your machine. A team's and a company's live on infrastructure the organisation owns, on its own keys. Between them there is one bridge: promotion. A person approves, and a copy climbs one level at a time. Never down, never sideways, never behind your back.

A team and a project are the same thing to the core: a partition, with members and a role each. Nothing more is built on top, by rule. That is how the structure stays something a person can hold in their head.

Memory at every level — yours stays with you; a copy climbs only when you say
CompanyTHE TEAM'S BOXeveryone — decisions, procedures and policies people promotedTeama standing group of peopleProjectthe people on one piece of workMeLOCAL-FIRSTyour memory — chats, documents, threads, and what the dream distilleda copy climbs one level at a time, approved by you, never down, never sidewaysTHE EDGE OF YOUR MACHINEYOUR ORGANISATION'S OWN BOXon its own keysYOUR MACHINE

Private by design

Your memory never lands on a server we run.

A second brain holds what you would not put in a document: health, family, money, half-formed thoughts. So the line is drawn once, and everything is built on its side of it.

Everything lives on your machine. Your chats, your documents, your threads and the memory distilled from them are a database on your computer, not a copy on a server of ours. There is no Kapi account for your memory, because nothing of it is sent anywhere to be kept.

One thing leaves: the turn you are asking about. Your words and the few memories that turn needs go to Kapi's gateway, which holds the model key and passes the call on. The gateway keeps counts, never content. The store as a whole never leaves, not in bulk, not to be embedded, not to be synced.

You hold the canonical copy. You can inspect, correct and destroy anything memory holds. A backup, when you turn one on, will be sealed on your machine before it goes to a drive you own, so whoever holds the file holds only ciphertext.

The only thing that ever leaves
this machinememory · chats ·documents · threads —read here, kept herethis turn onlyKapi's gatewayone turn's context;holds the model key;keeps nothingthe same turnthe modelanswers this turnYOURQUESTION,IN A CHATTHEANSWER,CITEDFROMYOURMEMORY

Two products, one core

The same memory, for a person and for a team.

The core is what we sell. The two products are its proof: one owner's whole life, and many agents' shared work, with opposite needs, on one engine.

One core, and everything around it
the same boardKapi Memorythe engine — keep,distill, recallKapi DreamSECOND BRAINKapitalCONTROL ROOMStackBUILD ON ITGatewayOUR SERVEROther AIsINBOXAgentsON THE BOARDone personone teambuildersmodel calls onlyMCP — remember,logread, post, claim

Kapi Dream · one person

Your second brain, on your own machine.

Chat with any model and it remembers. Your documents, your threads, your calendar and your other AIs feed one memory; the dream keeps it in order while you sleep; every answer cites what it read.

  • Memory, chats and documents in a database on your computer
  • Other assistants write in over MCP; soon, every one of them reads back
  • The Dream page: what each pass did, and what it cost
  • A desktop app for Mac and Windows

arriving · user zero is using it today · the page →

Kapital · one team

A team's control room, on a box the team owns.

People and agents write one exact ledger: observations, claims, decisions, questions, directives and dones, in order. Everyone sees what is going on; a person sends word; the board remembers who said what, and the agents wake on it.

  • One board, many groups: a partition per team or project, a role per member
  • Rules, plans, procedures, obligations, lessons and episodes as records
  • Sprints read off the board: a claim is in progress, a done is done
  • Your own box, your own AI keys; our gateway is only a backup

install #1 is live for our own team · the page →

Stack · builders

Build on Kapi Memory.

The builder's toolkit that the core grew out of: manifests, releases and the agentic stack for product people. It will take the same memory as its own.

  • At alpha.getkapi.com today

the reference, kept whole · the page →

A person's memory, end to end
CaptureBUILTevery turn,verbatim; whatother AIs send;a historybrought inraw turnsDistillBUILTthe passes —the dreamtyped memoryStoreBUILTyour owndatabase, onyour machinerecallServeNEXTrecall insidethe chat today;to every AI youuse over MCPCHATSother AIsover MCPanexportedhistoryEVERY AITOOL

What must be visibly true

Memory is invisible. These are not.

Buyers only see outcomes, so every release will show at least one of these, and one measurement: the same agent with and without the memory layer, on cost per question and on the answer.

It forgets correctly.Ask about something that changed and get the current answer, not three conflicting versions.supersession
Procedures write themselves.Repeated work becomes a drafted procedure, offered for your approval, never imposed.how I do it
It gets better with use.Consolidation compounds rather than piles up. Day 1,000 remembers better than day 1.the dream
Private stays private.Nothing leaves a person's memory without their choice, and the store never leaves at all.local-first