Every chat session ends with a small layoff

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

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

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.