AI Companies Know Your Data Is Valuable. Why Doesn't Your Team?

The most valuable thing your team produces with AI isn’t the code that shipped. It’s the path the agent took to write it — the prompts that worked, the retries that didn’t, the architecture decision someone made out loud before they touched the keyboard. That path is not exhaust. It is prior experience. Frontier labs have spent the last year paying a billion dollars a year to prove the point. Most engineering teams are deleting that path every time the terminal closes.

The vendor wants your session for training. The engineer means to save it for next time. The team needs to save it to learn from each other.

The labs already named what the path is worth

OpenAI COO Brad Lightcap put a number on the static-text era: if you combined all the proprietary text from major publishers and added it to GPT-4’s training mix, “it would boost the data volume by less than 0.1%.” Buying corpora is effectively over. What labs are paying for now is what Foundation Capital calls agency — “interactive reinforcement-learning environments with sequential action traces, not static input-output pairs.” That’s a long phrase for a simple idea.

The path through a problem is the asset.

Recent research is starting to point in the same direction. The systems that improve agent performance aren’t just keeping better prompts around. They are preserving prior runs — source changes, execution traces, prompts, tool calls, scores, failures, and state — so future agents can search across what happened before instead of starting from a blank context window. The lesson isn’t “stuff more into the prompt.” It’s: make prior experience durable enough to query.

Mercor, the marketplace that sells those traces to OpenAI, Anthropic, and six of the Magnificent Seven, crossed $1B in annualized revenue in June at a $10B valuation. The product is a session record — the full trajectory of a senior engineer and an AI agent working through a hard problem together. Surge AI, its closest competitor, named the thing right on the box: “thousands of hours of expert reasoning, pre-built and ready to use today, spanning RL environments, coding, and the core capabilities every model needs.”

And the model vendors are productizing it themselves. Anthropic and OpenAI are reportedly building services that store “the entire conversation record of the code-writing process, or trajectory,” so users can later look up the intent behind why code was written a certain way. GitHub flipped Copilot Free, Pro, and Pro+ to collect interaction data by default in April — “inputs, outputs, code snippets, and associated context” — used to train models unless you opt out.

The labs already named the thing. They called it trajectory. They’re paying for it, building products around it, and harvesting it from the tools your team uses every day.

Meanwhile, in your terminal

Your team’s sessions already contain the trajectory. Every prompt, every tool call, every retry, every fix. The same artifact Mercor sells at $200 an hour is sitting in your engineers’ shells today, and the moment they close the terminal, it’s gone.

Capture changes what that artifact can do. A captured session record is searchable. It’s replayable. It can be compared against the next run. It can show which prompt sent the agent down a dead end, which tool call recovered the task, and which context actually mattered. It turns yesterday’s one-off debugging session into tomorrow’s starting point. It’s something the next engineer can pull up when they hit the same Kafka config error your senior engineer solved at 11pm last Tuesday instead of opening a fresh prompt and walking through the dead ends one more time.

Without capture, the whole industry is admitting that the workflow trace is too fragile to lean on. Anthropic itself published a postmortem in May about a bug that quietly wiped session context every turn for nearly four weeks before anyone caught it. The vendor that builds the tool admits intra-session memory is fragile.

O’Reilly Radar put the daily texture bluntly: “Your AI partner — who just spent 20 minutes understanding your codebase — forgets everything and starts suggesting the same wrong approaches you already rejected.”

Mark Dominus wrote in March about how he now asks Claude to write a structured summary at the end of every project and commits it to the repo manually, because if he doesn’t scrape it out himself, the workflow knowledge is gone. He noted, with appropriate dryness, that developers will document for Claude what they won’t document for each other.

JetBrains researchers reported in April on telemetry from roughly 800 developers: context-switching trended steadily upward in the AI-assisted workflow, and 74% of those developers didn’t notice the increase. AI doesn’t uniformly reduce developer effort, the team argued. It redistributes it into more fragmented, reactive work that doesn’t show up on anyone’s calendar.

If you and the engineer next to you have each solved the same flaky-test config error more than once, you don’t have a model problem. You have a missing archive.

This isn’t a memory problem. It’s a capture problem.

Memory is what the agent can still see. Capture is what the team can still use. I’m not running data licensing strategy at a frontier lab. But the shape of it is clear enough from the outside. Vendor, engineer, team — none of those three groups has agreed on where the session lives, what format it’s in, or who owns it.

So most of the time, nobody saves anything. The session ends. The terminal closes. The next person on the team starts from zero.

What capture as a primitive looks like

Distributed systems solved a version of this in the 1980s. Every production database writes a write-ahead log. Every message queue checkpoints offsets. Every event-sourced system can replay its history from an append-only record. The assumption is that the running process will fail, and the next one needs to know what the last one did.

Agent workflows ignore those lessons. The model talks to the provider. The provider responds. The session closes. An hour of design work, dozens of tool calls, three debugging loops, and one extremely specific lesson about how a flaky integration test recovers — all of it evaporates when the user moves on.

Capture, as a primitive, is the thing that stops the evaporation. An append-only record of the work: every prompt, every response, every tool call, every retry, every fork in reasoning. Owned by the team, not the vendor. Queryable later, by humans and agents. An archive, not a scrollback buffer.

That’s the bet Paper Compute is making. Agent sessions are not disposable chat logs. They are the operational record of AI-assisted work. Capture them, and your team can inspect, compare, search, and eventually reuse what your best engineers and agents have already figured out.

The asset isn’t the code the agent produced. The asset is the path the agent took.

Start treating the session like it’s worth something

Capture your sessions. Tell the people you work with that what they figured out last Tuesday is worth saving — because Mercor is renting senior engineers at $200 an hour to record exactly that, and your team is doing it for free.

The labs already agree on what your team’s work is worth. Now your team has to start treating it like infrastructure.