![A long row of identical tiles; three near the centre have emptied to amber outlines, their contents drifting upward as particles and dissolving.](/assets/blog/p1-small-layoff.webp)

When a senior employee resigns, everyone understands what's about to happen.
There's a handover document that captures maybe a tenth of what they know.
There's an exit interview. There's the six-month period afterwards where
someone asks "why did we do it this way?" and the only person who knew is
gone.

We treat this as a serious, expensive event. Because it is.

Your organization now runs dozens of these events every day. You don't
notice, because they don't look like a resignation. They look like closing a
chat tab.

## Where knowledge actually gets created now

Over the last couple of years, a quiet shift happened in how knowledge work
gets done. The thinking - the actual reasoning, the weighing of options, the
discovery of constraints - moved into conversation. Conversations with AI
assistants, agent sessions, pair-work in a chat window. That's where the
pricing decision got argued out. That's where the vendor integration got
debugged. That's where you worked out that option B beats option A, and
*why*.

The session is where the knowledge is born. And the session is where it dies.

What survives is the deliverable: the email that got sent, the code that got
committed, the number that went into the spreadsheet. The conclusion escapes.
Everything that produced the conclusion doesn't.

## An inventory of what you lost today

![Four columns whose small solid bases remain while the much larger stacks above them dissolve into drifting fragments - the deliverable survives, the reasoning does not.](/assets/blog/p1-inventory.webp)

Take any substantial working session - human, agent, or both - and audit what
existed at the end of it that didn't exist at the start. It's more than the
deliverable.

**The decision and its why.** The choice gets implemented. The reasoning that
would stop you re-litigating it in six months evaporates. Six months later
someone - maybe you - asks "why don't we just do X?" and there's no record
that X was considered for two hours, had a fatal flaw, and was rejected for a
specific reason. So you spend the two hours again. Best case, you reach the
same conclusion. Worst case you don't, and you've reversed a decision that was
right without knowing you made it.

**Discovered constraints.** "That vendor's API can't handle partial updates."
"Legal won't sign off on that data flow." "This service silently expects dates
in DD/MM/YYYY, not ISO." These are small, hard-won facts. Each one cost real
time to discover - sometimes hours of debugging, sometimes a failed
deployment. In an older world, they'd accrete in a senior employee's head as
tribal knowledge. Now they accrete in a chat transcript that will never be
read again. The knowledge technically exists. Operationally, it's gone.

**Dead ends.** The three approaches that *didn't* work. Negative knowledge is
the most expensive kind to acquire and the most invisible afterwards, because
by definition it left no trace in the final output. The deliverable shows the
path taken; it says nothing about the paths that were tried and abandoned. So
the next person - or the next agent session - tries them again, at full price.

**Working state.** Where you were. What was in flight. What was tried, what's
pending, what the next step was going to be. Every session that ends without
capturing this forces the next one to start cold: re-reading, re-orienting,
re-deriving context that existed yesterday at 4:58pm.

No single item here is dramatic, which is why you never see the loss. A
resignation is one big legible event. This is a thousand small ones with no
line item anywhere.

## The accounting problem

Ask a CFO what the company's knowledge is worth and you'll get a shrug - it's
not on the balance sheet. Ask what it would cost to *reacquire* and the number
gets concrete: the consultant fees to re-learn a market, the
engineering weeks to rediscover why the last migration failed, the deals lost
while a new hire rebuilds context their predecessor had.

That's the correct test for whether something is an asset: **would you pay to
acquire it again?** If yes, it has a replacement cost, and losing it is a
write-off - whether or not your accounting system has a column for it.

By that test, what your working sessions produce is an asset.
Every discovered constraint has a replacement cost measured in debugging
hours. Every documented dead end has a replacement cost measured in someone
walking down it again. Every decision rationale has a replacement cost
measured in re-litigation meetings.

You write those assets off at the end of every session. Not by choice; no one
ever put the choice in front of you.

## "But we have a wiki"

The standard objection: important things get written up. Documentation exists.
There's a Notion.

Two problems.

First, "write it up later" fails for reasons that have nothing to do with
discipline. Capture that happens *after* the work competes with the next
piece of work, and loses. The
write-up captures the conclusion (which was going to survive anyway, in the
deliverable) and drops the reasoning, the constraints, and the dead ends
(which were the expensive parts). By the time anyone sits down to document,
the expensive material has faded. A week on, nobody remembers which
alternatives they rejected or why.

Second, even the things that do get written down get written down *once*, at a
point in time, then drift out of date without telling anyone. That's a Part 4
problem. The Part 1 problem is more basic: the overwhelming majority of
session-generated knowledge never makes it into any system at all.

## Agents make this worse before they make it better

Move more of your knowledge work through AI agents and the leak rate climbs. An agent session generates the same categories of knowledge a
human session does - discovered constraints, failure modes, working state,
rejected approaches - but faster and in higher volume. An agent can burn
through a dozen dead ends an hour. Unless something catches those learnings,
every one of them is re-purchased by the next session, forever.

Take some comfort in this being an old problem. Organizations have leaked
knowledge for as long as they've had any; agents opened the tap wider. The
same instrumentation that lets an agent lose a learning at machine speed can
catch it at machine speed.

## The exit interview for a chat tab

![Two doorways side by side: the left one amber-framed with a small tray of neatly stacked items beside it, the right one grey with fragments scattered past its threshold and nothing kept.](/assets/blog/p1-exit-interview.webp)

Companies run exit interviews for departing employees. They're imperfect, but
they're a deliberate attempt to catch knowledge before it walks out the door.

Nobody runs one for a closed session. There is no moment where anyone asks:
what did this session learn that the next one will need? What did it discover
the hard way? What did it rule out?

Not because the answers wouldn't be valuable. Because there's nowhere for them
to go, and no process that asks.

Fixing that - making capture ambient, cheap, and automatic at the point of
creation rather than an afterthought that never happens - is Part 2.

---

*Next in this series: **[Capture - stopping the leak at the point of
creation](/blog/capture-stopping-the-leak).***