Your Agent Needs Two Memories

Somewhere in your company today, someone made a call that mattered. They priced a deal off a hunch that took three years to earn. They killed a feature for a reason nobody wrote down. They learned why the last deal died, told two people at lunch, and moved on.

Six months from now, your company will pay to learn all of it again.

This has always been true, and it has always been tolerable, because human institutions leak knowledge slowly. Agents change the math. An agent acts on what it can retrieve, at scale, without the skepticism a person applies. Whatever your organization cannot retrieve, your agents do not know. And the most valuable knowledge you have is precisely the kind nothing retrieves, because it was never stored anywhere at all.

That is the real problem with agent context. Everything else is plumbing.

Where does truth live?

Ask where an agent’s knowledge should come from and you get a debate about architecture. Retrieval versus memory. RAG versus knowledge base. Fetch it live or write it down. Teams pick a side and build.

The debate misses that knowledge comes in two kinds, split by one question. Where does truth live?

For a huge class of knowledge, truth already lives somewhere. The ticket lives in Jira. The invoice lives in the ERP. The customer lives in the CRM. Copy any of it into your agent’s memory and you have not built knowledge. You have built a cache, and every cache has one destiny. It goes stale, quietly, while your agent serves yesterday’s truth with today’s confidence. For this class, the answer is pull. Fetch it live, act on it, throw it away.

But the knowledge from the opening paragraphs, the pricing judgment, the rejected feature, the lost-deal pattern, has no system of record. There is no Jira for judgment. It lives in chat threads and in the heads of whoever was in the room, which means it lives nowhere an agent can reach. You cannot pull it on demand because there is nowhere to pull it from. For this class, the answer is persist. If you do not write it down, it does not exist.

Pull what has a system of record. Persist what does not. That is the whole rule. It is also the easy part.

Apply the test to anything an agent touches. Ticket status? Jira owns it. Pull. Why the enterprise tier excludes SSO? No system owns that. Persist. The customer’s contract terms? The CLM owns them. Pull. What the customer said made them nearly walk last renewal? Persist. When a piece of knowledge fails the test both ways, it is usually two pieces fused together: a fact that belongs to a system, wrapped in a judgment that belongs to you. Split it, and store only your half.

A folder is not a memory

The hard part is what “persist” has to mean. Most companies hear it and create a folder. A context file. An onboarding doc. A “facts the agent should know” page loaded into every session.

Every one of those documents dies the same death, and it is not a discipline problem. It is structural. A flat document has no write path, so knowledge from daily work never lands in it. No item identity, so three versions of the same pricing claim pile up and nobody knows which is current. No conflict handling, so new claims sit beside the old claims they contradict, looking equally official. No decay model, so a fact from last March carries the same confidence as a fact from last week.

A context file that is 80% accurate is worse than useless. You cannot tell which 80%.

Teams trust the file for a quarter, doubt it for a quarter, and abandon it by the third. Every company runs this experiment. Every company gets this result.

Memory that works runs a lifecycle, and the lifecycle is a set of rules you can enforce at write time. Capture happens as a byproduct of work: when an agent finishes a session, it files what was decided, not what someone remembers to document later. Every item gets an identity, an owner, and tags, so the write path can ask “does this already exist?” and merge instead of collect. Every new claim gets checked against the old ones, and a contradiction gets flagged in both places rather than absorbed in silence. And every perishable claim carries a date and a shelf life. Competitive intel expires in 90 days. Metrics go stale in two weeks. A claim past its window announces its age instead of impersonating the present.

None of this needs exotic infrastructure. A git repo of structured markdown gives you provenance, sync, and access control for free, and any text editor can read it if the tooling disappears tomorrow. The hard part is not storage. The hard part is refusing every write that skips the lifecycle. A folder refuses nothing.

Thin skills, thick brain

Get the two kinds of knowledge into the right homes and the whole architecture falls out.

Bottom: your systems of record. They own operational truth. Agents pull from them live and keep nothing.

Middle: the brain. The durable, lifecycle-managed store for everything with no other home. Decisions, positioning, syntheses, verified claims. Written once, disputed visibly, expired honestly.

Top: the skills. Each defines how a function thinks. How product writes a spec, how marketing builds a battlecard, how sales preps a deal. Skills stay thin because they hold judgment rules, not facts. Every fact comes from below.

This is what makes knowledge compound. Research files a finding; the spec skill sees it. Competitive intel updates a teardown; the battlecard refreshes and the deal prep sharpens. No meeting. No copy-paste. Give each function a private context file instead and every one of those connections dies.

It also makes the build cheap. The lifecycle machinery lives in the brain, built once. Every new skill inherits capture, dedupe, conflict handling, and decay on day one.

How to start

Do not start with a platform decision. Start with a repo and six weeks.

Weeks one and two, seed it. Take the context files you already have and migrate them into typed, tagged items with owners. This migration is the first payoff: it will surface duplicates and contradictions you did not know you had, because a flat document hides them and items cannot.

Weeks two through six, put it in the write path. Wire the brain into the agents your team already uses, so capture happens during normal work: wrap up this session, file this decision, save this analysis. This is the step most efforts skip, and it is the one that matters. A memory nobody writes to during work is a documentation project, and you already know how those end.

One rule from day one: provenance is non-negotiable. Every write carries an author and a date. Every claim traces to a person. An unattributed claim is not knowledge; it is a rumor with formatting.

Then split the governance question in two, because it is really two questions. Anyone can capture: observations, field intel, customer feedback, drafts, all fully attributed, all understood to be raw. But promotion to canon, the claims agents treat as organizational truth, runs through stewards who review and merge. Govern what becomes official, not who gets to contribute. Machinery can catch a duplicate; only judgment can decide what deserves to be canon.

Finally, measure the memory like the system it is. Watch how long flagged contradictions sit unresolved, how many stale items accumulate, how often a capture duplicates an existing item, and whether people who are not stewards actually read from it. A brain nobody reads is a diary. The read-side numbers tell you whether you built memory or paperwork.

The knowledge you are losing right now

Come back to that deal priced on a hunch. In a company running this architecture, the agent that helped prep the deal files the reasoning as it works. The claim carries an owner, a date, and a shelf life. The next seller’s agent retrieves it, notes it is four months old, and flags the one assumption the market has since overturned. Nobody scheduled a documentation sprint. Nobody got interviewed before they quit. The knowledge survived because capturing it was a side effect of using it.

Your agents are only as good as their context. Half of it sits in your systems of record, waiting to be pulled. The other half is walking around in people’s heads, evaporating one departure, one scrolled-away thread, one forgotten lunch conversation at a time.

Build for both halves. The companies that do will remember. The rest will keep paying to relearn what they already knew.