Agent context is the new technical debt

Last week I closed a terminal window and lost three hours of reasoning.

Not code. The code was committed. What I lost was the conversation: the constraints I gave the agent, the two approaches it tried and I rejected, the edge case that led us to the final design. A week later, a colleague asked why the function works the way it does. I stared at the diff and couldn't fully reconstruct my own decisions.

This happens constantly now. The more I work with AI agents, the more valuable the reasoning becomes, and the less of it survives.

What git doesn't capture

Git was built to version code. It tracks what changed, who changed it, and when. For human-written code, that's usually enough. You can read a diff and understand the intent. The reasoning lives in the developer's head, in the PR description, in a brief commit message.

AI-generated code is different. A single agent session can produce hundreds of lines across multiple files. The output is a function of everything that happened in the session: the initial prompt, the clarifying questions, the constraints you added mid-conversation, the approaches the agent tried and abandoned, the corrections you made along the way.

Git preserves the final artifact. The reasoning that produced it lives in a terminal window that doesn't persist. Close the session, and the "why" behind the "what" is gone.

This isn't just an inconvenience. It's a new category of information loss. When I wrote about letting AI supervise itself, the workflow assumed you could trace decisions back to their source. Without durable context, that traceability breaks down.

The compounding problem

One lost session is manageable. You remember most of it. A dozen lost sessions across a week starts to hurt.

I run several agent sessions a day in Cursor. One for the data layer, another for the UI, sometimes a third to refactor what the first two built. Each session builds its own context: decisions made, patterns followed, constraints discovered. When I commit, the code merges cleanly. The reasoning behind it stays siloed in sessions I've already closed.

The cost shows up later. I start a new session on code I generated last week. The agent doesn't know what I already tried. It suggests approaches I rejected. It misses constraints I spent twenty minutes explaining to a previous session. I correct it again. Tokens wasted. Time wasted.

For teams, this multiplies further. A colleague picks up where I left off. They see the code, but not the session that produced it. They can't tell if a pattern was intentional or if the agent just happened to generate it that way. They re-derive context I already had, or worse, they change something that was deliberately designed around a constraint they can't see.

This is technical debt, but not in the code. In the missing reasoning.

What Entire does

Entire is an open source CLI that makes agent context durable. It introduces Checkpoints: a primitive that captures the full agent session alongside each git commit.

When you commit code generated by an agent, Entire captures the transcript, prompts, files touched, token usage, and tool calls. This metadata gets stored on a separate git branch called entire/checkpoints/v1, invisible in your normal commit history. Your code stays clean. The reasoning rides alongside it.

You can browse checkpoints by branch, drill into individual sessions, and trace how a piece of code evolved through human-and-agent collaboration. When you revisit code, you can read the session that produced it. When a teammate picks up your work, they get the context, not just the diff.

Two strategies are available. Manual-commit (the default) creates checkpoints when you or the agent commit. Auto-commit creates them after each agent response, giving you finer-grained save points. Both support rewind, so you can roll back to any checkpoint in the current session.

Setting it up

Setup takes two commands:

brew install entireio/tap/entire

Navigate to your repo and enable:

entire enable

Follow the prompts. That's it. Your agent sessions are captured automatically from that point forward.

Entire works with Claude Code and Gemini CLI today. Codex and Cursor CLI support are coming, along with community-contributed integrations for other agents. The project already has pull requests open for several additional agents.

MIT licensed. The CLI source is on GitHub.

Why this matters

Entire is built by Thomas Dohmke, former CEO of GitHub, backed by a $60 million seed round. The vision goes beyond session capture. The team is building toward a semantic reasoning layer where agents can share context, hand off work, and coordinate without losing the thread of decisions made in earlier sessions.

Checkpoints are the first step. Today they give you traceability and history. The roadmap points toward shared agent memory: a system where starting a new session doesn't mean starting from scratch.

I've written this whole series on AI-assisted development from the assumption that the developer is the one holding context together, through rules, through plans, through documentation tools. That works when you're the bottleneck. It breaks when agents start working autonomously across sessions and team members.

Durable agent context is the piece I've been missing. The code is the output. The reasoning is the asset.

Links

• GitHub: entireio/cli
• Blog: Hello Entire World
• Website: entire.io