Every era of business has run on a new kind of data it learned to capture. Double-entry bookkeeping turned transactions into a ledger, and made the modern corporation possible. Version control turned every change to a codebase into history you could query, and made modern software possible. The pattern repeats: a new asset class shows up, the companies that learn to mine it pull ahead, and everyone else keeps working from memory.
There is a new one now, and most people are still treating it as exhaust.
The trace
It is the trace - the record of how the work actually happened. Every AI conversation your team has, every run an agent makes, is now written down. The trace contains what was tried, what got thrown out, which files got touched, what broke, and why the call went the way it did, timestamped and sitting right next to what it produced.
For most of history, information like this had been thrown out. The company kept the document and lost the ten conversations that shaped it. It kept the merged code and lost the wrong turns and the "wait, no" that got it there. The most honest account of how a company works evaporated the moment it happened, and every company quietly paid to rebuild it - onboarding, re-deciding settled questions, relearning why the last person did it that way, right after they quit.
Such data stops evaporating now because the surface of work has moved. More and more of your team's real thinking happens through AI agents, and when it does, the record comes off the work on its own. The trace is a byproduct, since it's just the trail you leave by doing what you were already going to do. Nobody has to keep a ledger or remember to commit. Storing and processing it is our job at Nessie, but the data itself is already there, minted a little more every day as you work.
That is what makes it different from the asset classes before it. A ledger had to be written. Version history had to be committed. This one gets left behind on its own.
And it is unusually rich. A trace has a deterministic half and a non-deterministic half - the exact files, tool call commands, and artifacts on one side, the reasoning and the judgment and the messy back-and-forth on the other. Most data is one or the other. A trace is both, which is a lot of what makes it worth mining. It is also, simply, yours.
Mining it
Capturing the asset is the foundation, and most of the hard, unglamorous work. Your conversations and traces are scattered across every AI tool your team touches. Pulling them into one place an agent can actually work across needs to be done right before anything else is possible.
The value is in what you mine from it. Once the foundation is there, you can:
- ask what your team already decided about something, and get the answer with the reasoning still attached
- take a line of shipped code and walk it back to the conversation that produced it
- find the workflows that keep breaking, and fix them at the source instead of one incident at a time
- see where the team is actually struggling, instead of guessing
And it gets a little sharper every time it is used, because every question asked and every answer corrected is one more thing it now knows.
That is the whole idea. A company that mines its own record learns from itself, and gets better at being itself. We are early enough that nobody has mapped the full space of what you can do with a company's own traces, which is the fun part - and the reason I think this is the asset class that matters most this decade.
Why it stays yours
Two things make this durable, and neither is a head start that closes when the models catch up.
You run many models, and you can't own them all. No company runs on a single model, and increasingly none will - one for coding, another for research, whatever is best this month, a specialized one for the thing nobody else does well. No company can train or own all of them, and none should try. The one constant, the thing that is actually yours, is the data layer every one of those models plugs into. The models come and go. Your traces compound.
The incentives point in opposite directions. A lab wants to absorb your knowledge into its models. You want the reverse: keep your edge out of a model your competitor also queries, keep it portable so you are not locked to one vendor, keep it legible so you can see why your agents did what they did. Those incentives pull apart, and they keep pulling apart no matter how good any single model gets.
The recursive company
A new asset class always ends up drawing the shape of a new kind of company. The ledger gave us the corporation. Version history gave us modern software. The trace gives us something we do not have a clean name for yet: a company that holds the full record of its own work, mines it, and gets a little smarter every time it looks.
Most companies keep the outputs everyone already agrees are worth keeping. The recursive company keeps the record only it could ever have had, and puts it to work. That is the company we are building for - and, increasingly, the only kind worth being.