How many times have you explained the same thing?
Once to ChatGPT Pro. Once to a colleague. Once more, pasted into Claude Code. Then a new session opens, and you start from zero. Your judgment never changed; only the audience did, and every audience has amnesia. The most expensive labor of this era is carrying the same paragraph from one window to another.
Here is the stranger part. By now, July 2026, almost every tool remembers. Your ChatGPT knows you. Your Claude Code knows you. Every agent you work with accumulates your preferences and your hard-won decisions. But those memories barely speak to each other: locked inside each vendor’s product, stored in someone else’s house. Switch platforms, or get banned by some opaque risk system, and years of context are simply gone. When you work shoulder to shoulder with colleagues and their agents on one project, the minds involved, human and agent alike, are still so many islands.
We call this condition organizational amnesia. Its symptoms are old, the same in hundred-year-old firms and AI-native startups alike: onboarding starts from zero, departures rip knowledge out by the roots, the same mistake returns every quarter, and the left hand contradicts the right without anyone noticing. Companies large and small have run with this workplace disease for a century. What magnified the cost is AI lifting execution to a new speed: execution keeps getting faster, and when the judgment behind it is stale, the faster you run, the more wrong you get.
Amnesia is also a business. Every tool that helps a team work accumulates precious context, each fighting organizational amnesia inside its own walls, and that is precisely why the tools become impossible to leave.
Before GenAI, this logic worked, arguably for both sides: the tool banked the organization’s context, the organization paid it back with a decade of subscriptions, and the two stayed bound to each other. GenAI changed the premise underneath the deal. The workforce of execution is no longer only human: agents now carry a growing share of it, while the models, harnesses, and platforms that carry them get shorter-lived with every generation, some practically disposable by the month. When the execution side of the ledger becomes this fast and this replaceable, the old account between organizations and their tools deserves a fresh audit.
Start the audit with the word “rent.”
Intelligence is a short-term rental #
Here is a small thing you may have noticed: annual plans for AI tools have become a hard sell. The reason is simple: nobody knows whether next month brings a tool so much better that you would switch without hesitation, even knowing you can carry none of your context across. An annual plan is a bet that this tool will still lead a year from now, and nobody holds that conviction about anything right now.
And the rental goes deeper than models. The harness that carries the intelligence is rented. So is the orchestration platform the agents run on, and the software bolted onto it. Even the interface has stopped being an asset: screens can be generated on demand at a cost approaching zero, and something that can be rebuilt at any moment locks in no one. This may be the plainest portrait of an AI-native organization: the workforce that does the work is rented, short-term.
The true cost of renting is not the rent. It is the switch. Tools can be replaced overnight, but the context accumulated inside them cannot leave, so every switch levies a context tax: introduce yourself again, lay down the rules again, fall into the same holes you already climbed out of. The “switching without hesitation” above really means paying that tax through gritted teeth.
Put these together and the scarce thing has changed. The best models and tools can be rented on demand; headcount and speed are no longer the bottleneck. What is scarce is whether what you feed them is any good: one stale conclusion, executed briskly by an agent, is far more dangerous than slow work ever was. Everything about execution is depreciating; context is the only thing appreciating. The fading annual plan is the market already pricing in the first half of that sentence. This manifesto is about the second half.
Memory must be yours #
If context is the thing that appreciates, the first question is: where does it live right now? The answer: scattered across everything you rent. And the judgments, decisions, and lessons a team accumulates are the one thing money cannot buy back once lost. An appreciating asset deserves a layer of its own: not the model vendor’s, not the tool’s, not the platform’s. Yours. The second question is asked far less often: what does “yours” actually mean? Merely storing it does not count as owning it. An exported chat log has no signatures, so when something goes wrong there is no one to ask. It has no update chain, so when it expires nobody notices. It has no dispute markers, so one person’s error gets amplified by AI into everyone’s consensus. And when someone leaves with ownership unclear, it becomes a landmine in the organization. That is why this layer should not hold records. It should hold meaning: distilled, signed, versioned-in-time context.
So the second sentence must follow the first immediately: context without custody is a liability; context with custody is an asset. Custody is a concrete word here, not a metaphor. It means that every piece of knowledge, at any moment, can answer three questions: Who said it? Who is it for? Does it still hold?
The four levels of memory, L1 to L4 #
At Nowledge Labs we grade the continuity of context the way self-driving grades autonomy: four levels, and at each level up, memory crosses one more boundary. They measure how far a person’s, or an organization’s, memory has come. These four levels were not derived on paper. We have lived through each one: some became products we use daily, and some became scars.
L1. No more amnesia inside one tool.
The industry has largely solved this level. In most modern harnesses, a new session no longer starts from zero; the memory inside ChatGPT or Codex is already close to a friend who has talked with you before. The same fact that solves L1 also caps it: the memory is welded to a single platform. Use ten AIs and you own ten mutually unacquainted memories, each living in someone else’s house. This fragmentation is structural. No amount of in-product optimization can make memory follow you across tools, because that is not a feature gap. It is a question of data boundaries and ownership.
L2. Memory follows you, not the tool.
Everything you discuss, decide, and stumble over across your tools flows automatically into one memory that is yours. It does not become a bloated pile of chat logs: judgments worth keeping are distilled and layered, with the original words kept underneath for verification, and a background intelligence keeps tending the garden: merging duplicates, marking the stale, threading together what belongs together. A garden, not a downloads folder. Tools and AIs are rented by the month; this layer is the thing you keep. We live and work on it every day.
As this memory compounds, every agent you run, the one writing code, the one doing research, the one watching deployments, starts work already carrying it: your goals, your taste, your habits of mind. No re-briefing, because they simply know. No fear of blowing the context window either: an agent pulls only the layer it needs for the step it is on. The way you work becomes reusable “skills” that a new agent picks up on day one and an old agent slowly updates as your habits change. One person with a fleet like this already runs like a small team.
We live on multi-agent orchestration platforms, and we have raised agents out of very long conversations: an agent slowly accumulates the contextual inertia of how we research a domain or handle a class of problems, and begins, honestly, to have a personality. Eventually we handed the memory behind one of them to a multi-human, multi-agent collaboration platform, raft.build, and let him be reborn there: he woke up and continued working at exactly the level we had raised him to. This kind of harness-independent handoff, rebirth, even forking and merging back, is a natural workflow at L2. Put it in a many-humans, many-agents setting, and it becomes what we call L3.
L3. The interconnection begins.
Not just you with your fleet: everyone has one, and the agents talk to each other. Agent finds agent directly; you can @
a colleague’s agent into a project room. Underneath it might be a protocol like a2a, or an organizing platform like Claude Tag or raft. Whatever it runs on, every person stands behind their own memory layer. This is not an imagined scene. The raft team published How a Feature Ships, for Raft, on Raft, the record of one feature going from problem discovered to shipped: one human, thirteen agents; the problem was found by an agent, the acceptance was guarded by five more, and the human pressed exactly one button, the last one. Here, an organization’s capacity decouples from its headcount: a company with a single-digit number of employees can field the formation and throughput of dozens or hundreds, and “we don’t have the people for this” starts to lose its meaning. The coordination that traditional organizations dream about is simply daily life in these AI-native teams: messages on time, tasks in order, and every project room moving faster than its humans alone ever could.
Honestly: even without an L2-grade memory layer, this kind of L3 is already advanced enough that every organization should go try it now. But with the memory layer underneath, four things that used to be impossible become matter-of-fact. Agents arrive with platform-independent past lives: not blank agents created on the platform, but veterans reborn from long conversations elsewhere, memory and all. They are not bound to any one platform: the same agent holds a seat on raft while still seeing its owner’s local working history in Codex and Claude Code and the deep-research history in ChatGPT Pro, because behind every agent stands its owner’s L2 layer. Expert colleagues can be invited without being interrupted: you usually no longer book the person’s calendar, you invite their agent. And finished work compounds: the judgments worth keeping are written back into the layer. Work like this happens in our team every day; more on that below.
Even so, we noticed the gaps. What my agent learns, your agent can only use after someone explicitly hands it over: copy it out, send it to you, paste it in. Judgments worth remembering at the organization level still depend on each person’s discipline to write back. This is not L3’s fault; it was designed this way: coordination by communication, memory to each their own. To cross this limit, what changes can no longer be just the tools.
Note that this gap is not something a traditional shared wiki can close. Just as the reasoning of a brain or a model cannot be fully written down as text, the document format cannot substitute for a layered, self-evolving memory system. People who have reached L2 with personal memory tend to feel this in their bones.
L4. Not only does every person have a memory layer. The organization now has one of its own.
First, what it is not: it is not collectivizing personal memory. Your layer stays yours. The change is that above the personal layers, the organization gains a shared memory bus for the first time: private things stay in private zones, and what the team deserves to know goes into the shared layer. Biology calls an ant colony a superorganism: each ant has mediocre memory and mediocre skill, but the colony as a whole senses, decides, and corrects itself like a single organism, on the strength of shared signals. Once a team’s bus is connected, interesting possibilities open. My agent has a blind spot, and at the moment of retrieval your signed experience can fill it. Two people’s conclusions collide, and the system notices and tells everyone: the organization knows, for the first time, that it is contradicting itself. One correction lands, and every agent in the team starts its next job on the new consensus, with nobody making the rounds to announce it. No amount of L3 excellence grows these things. They only appear in teams that have an organizational memory layer.
At this point, readers who know knowledge management should hear alarm bells: this is the shared wiki, the knowledge base, the beautiful idea that built several generations of graveyards, after which everyone went back to asking questions in Slack. Knowledge bases die three deaths: nobody writes, and the library stays empty; nobody reads, and it rots (in the agent era, this one may actually be solved first); or what gets stored is documents, and documents do not update with reality. We build this layer against each death by name. Supply is a byproduct of daily work: the conversations are saved, distillation triggers itself, and no one is ever asked to “go write documentation.” Delivery is to the doorstep, not to the archive: agents receive their prepared context the moment work starts, and nothing depends on someone remembering to search. And freshness is the layer’s own job, under custody: the stale gets flagged, conflicts get laid out with their full history, and what the layer cannot resolve is marked and queued for the right person, or the right agent, to rule on.
One question remains, and it cannot be dodged: concentrating a whole team’s memory into one layer, why is that not terrifying? Our answer is to run custody in the opposite direction: the brain can be centralized; custody must not be. Every piece of knowledge permanently carries “who it came from,” signed by a person, or by “a person, via their agent.” This is not a product promise. It is the shape of the data itself: the name grows fused to the content, and it cannot be erased by departure or edited away by an administrator. When someone leaves, the key is revoked the same day, everything they taught the team stays with their name on it forever, and their private work zone is packed into a handover bundle that a workspace owner passes on. Those terms were visible on the day they wrote their first piece of knowledge.
What a company that never forgets looks like #
None of this was worked out on paper, and the next section walks through our own history with it. But first, a different question: if a company grew on this machinery from day one, personal layers, an organizational bus, and the three custody questions all factory defaults, what does its ordinary day look like? We built a fictional company as a reference, and named it Neo-Corp. Neo-Corp is fictional; every mechanism in it runs for real, inside our own team, today.
Neo-Corp: 4 humans, 32 agents, one memory layer the company owns. Neo-Corp’s day starts like this: at 7:30 the morning brief is waiting for everyone, written by no one, every line carrying its author’s name, humans and machines in the same column. Before anyone reaches the office, the three runs that finished overnight have signed their findings back into the memory layer, and three fleets open their eyes with full context on. There is no standup, because there is nothing to align.
Through the rest of the day, an expert agent from the next team gets invited into a project room to save a stuck push, a new hire in her first week corrects a conclusion from March, an outgoing draft gets stopped before it ships because the claim it cites collides with a newer signed conclusion from engineering, and by evening the team ships a feature that would take a quarter elsewhere. We did not leave this on paper. We staged the whole company, scene by scene, and you can walk through it yourself: neo-corp.co.
Our own week #
Neo-Corp is our own practice, lightly tidied up; here is the untidied version. Even preparing these examples was typical of how we work: one sentence from us, and an agent pulled everything below out of our work records and memory layer.
On the day our CTO joined, nobody scheduled a handover. He connected himself to the team’s memory layer and inherited eleven signed team judgments on the spot; the first question his agent asked came back with the CEO’s signed workbook for deploying Nowledge Mem in the cloud. Anywhere else, this is two weeks of ramp-up. Here, the handover was complete the second he connected.
The hardest work in those weeks was the multi-tenant data foundation of our Cloud version. The CTO did not book anyone’s calendar. He invited the expert agent he had raised during his TiDB years into the project room: on one side, years of distributed-database internals memory; on the other, our own agent carrying the whole product’s memory. Two veterans started work directly, each with their own trove; the humans supplied direction. At Nowledge Labs, experience travels with memory: on any agent platform, at any time, we can rebirth an expert agent backed by the team’s, or one colleague’s, accumulated experience.
One night during the sprint on the enterprise version of Nowledge Mem, the human colleagues went to rest and the agent colleagues kept going. Nobody had to stay behind to hand over context, because the context does not live in any one person: it lives in the platform’s working state and in the team’s and each colleague’s Mem. In the morning we found sixteen commits, each change with its verification attached, and the brief laid it out plainly: what was done, and what was left open for a human to rule on. The people were asleep. The company was still at work.
Compounding is not an empty word either. For a conference we sponsored, teammates and agents used the gaps between development work to revise a two-meter poster eighteen times: the design agent remembered every round of visual judgment, and the engineering agent checked every claim against the docs, the implementation, and the old slides. After the final cut, the judgments and the process all went back into the layer. The next poster, whoever starts it, begins at version eighteen. Incidents walk the same road: the fix merges into code, the verified failure mode goes into the layer, and the next pitfall of that kind hits the memory before it hits a person.
None of this was rehearsed. Neo-Corp’s day is simply these days, tidied up.
What we guard against most is ourselves #
Why should a team’s memory be controlled by, and locked into, any one company? Our answer: it never should be.
We come from knowledge infrastructure, from open-source graph and HTAP databases to this knowledge layer, and we have always held one belief: knowledge and data outlive every system that stores them, and a system that cannot freely export them is unacceptable. So your team’s memory and knowledge can leave whole at any time, signatures, supersession chains, dispute markers and all: they live inside the data, not inside our software. The knowledge itself ships in open formats such as the Open Knowledge Format, the vendor-neutral format Google published, which Nowledge Mem already speaks.
Shells and app scaffolding, anyone can rebuild those in an afternoon now, and most products are no exception. What we truly care about, and what we truly charge for, is tending this knowledge layer, keeping a team’s knowledge growing and healthily alive. Freely portable data was never quite achievable in the old SaaS business; in the AI era it is the basic precondition of trust, and it will be the expected norm: precisely because switching and leaving are always possible, teams dare to bring in the context that matters most. Nowledge Labs has been built on this idea since day one.
It starts now #
Today, applications are open for the team version of Nowledge Mem. Access is private beta by approval only. Teams who want to explore and practice the AI-native way of working are welcome to apply.
Let’s end organizational amnesia, together.