Skip to main content

​
Sessions

A session represents a complete interaction with an AI coding agent from start to finish. When you start Claude Code, or another supported agent, Entire automatically creates a new session.

​
What’s Captured in a Session

  • Conversation transcript - The prompts you sent and responses from the AI
  • Code changes - All file modifications made during the session
  • Checkpoints - Save points you can rewind to
  • Token usage - Input/output tokens, cache usage, and API call counts
  • Metadata - Timestamps, agent type, and configuration
  • Line Attribution - A calculation of how many lines agents and humans contributed to the session
All sessions are stored locally in your project folder as well as on GitHub when you push. To find your raw session data on GitHub, check out the Sessions Branch section below.

​
Nested Sessions

When an AI agent spawns sub-agents (like Claude Code’s Task tool), Entire captures these as nested sessions within the parent session, preserving the full hierarchy of interactions.

​
Checkpoints

A checkpoint is a snapshot that you can rewind to—think of it as a “save point” in your work. Checkpoints have a 12-character hex ID, like: 8a513f56ed70, You’ll find Checkpoint IDs in the web application as well as in the CLI.

​
Types of Checkpoints

Created on shadow branches during active sessions. These contain the full state snapshot with code and metadata, allowing you to rewind at any point during your session. Shadow branches are named entire/<sessionID>-<worktreeID>, but remain local.
When you make a Git commit, the checkpoint metadata is stored permanently on the entire/checkpoints/v1 branch, which gets synced with your upstream. The checkpoint ID is added to your commit message as a trailer:
Add user authentication

Entire-Checkpoint: a3b2c4d5e6f7

​
When Checkpoints Are Created

Checkpoints are created when you or the agent make a Git commit. Entire captures all session data during your work, and when you commit, the checkpoint metadata is permanently stored and linked to your commit.

​
Capture Strategy

Entire captures all interactions in memory and on shadow branches as you work, but only creates permanent checkpoints when you or the agent make Git commits. This keeps your Git history clean while still providing full session capture.
  • No extra commits on your branch — only your commits appear in history
  • Safe on any branch — including main
  • Full rewind capability — can still rewind during active sessions via shadow branches
  • Clean pull request history — no noise from auto-generated commits

​
Branches

Entire uses special Git branches to store session data without polluting your working branches.

​
Shadow Branches

Format: entire/<sessionID>-<worktreeID> Shadow branches are temporary branches used to store checkpoints during active sessions. They enable the rewind feature by holding snapshots of your code at each checkpoint. The IDs are opaque. Shadow branches are automatically cleaned up and are not pushed to remote repositories.

​
Checkpoints Branch

Name: entire/checkpoints/v1 The checkpoints branch is a permanent branch that stores metadata for all completed sessions and checkpoints. This branch is pushed to your remote repository, allowing you to view sessions on entire.io.
The checkpoints branch only contains metadata (JSON files), not your code. Your code remains on your normal branches.

​
Checkpoint Linking

Entire links checkpoints to your commits using Git commit trailers: 
feat: Add login form validation

Entire-Checkpoint: a3b2c4d5e6f7
This bidirectional linking allows:
  • Finding the session context from any commit
  • Using entire explain to understand how code was written
  • Viewing session details in pull request reviews

​
Folder Structure on GitHub

The entire/checkpoints/v1 branch contains all your checkpoint and session data, sharded by the first two characters of the checkpoint ID: 
entire/checkpoints/v1 (branch)
├── 0b/                              # Shard (first 2 chars of checkpoint ID)
├── 0c/
├── 0f/
│   ├── 45ffa1b752/                  # Checkpoint (remaining chars)
│   ├── 4637ba1146/
│   └── f8ca6db1c9/                  # Full ID: 0ff8ca6db1c9
│       ├── metadata.json            # Checkpoint metadata
│       └── 0/                       # Session folder (numbered)
│           ├── content_hash.txt     # Hash of the content
│           ├── context.md           # Markdown of your prompts
│           ├── full.jsonl           # Full transcript with agent
│           ├── metadata.json        # Token usage, attribution, etc.
│           └── prompt.txt           # Raw prompts submitted
├── 10/
├── 11/
└── ...

​
Finding Your Session Data on GitHub

  1. Click on the branch dropdown in your project repo and select the entire/checkpoints/v1 branch
Screenshot of a checkpoint branch
  1. Then using either the search bar to the right of the branch dropdown or using CTRL+F, search for your checkpoint. It will highlight a folder for you to click on.
Screenshot of a checkpoint search
  1. You will then see a metadata.json file which is the parent metadata file for all of your sessions. If you only have one session in that checkpoint then you will only see one folder:
Checkpoint
If you have multiple sessions, then you will see multiple folders. 4. Click into a session folder to see your session files:
Session files

​
Token Usage Tracking

Entire tracks token usage for each checkpoint:
  • Input tokens - Tokens sent to the AI
  • Output tokens - Tokens received from the AI
  • Cache creation - Tokens added to context cache
  • Cache reads - Tokens retrieved from cache
  • API calls - Number of API requests made
This helps you understand AI usage patterns and costs across your development.

​
Line Attribution

Entire tracks how much of a commit came from the agent vs you. When you commit code after working with an AI agent, the CLI calculates what percentage of the changes were agent-written vs human-written. This is captured in the Entire-Attribution trailer on commits: 
feat: Add user authentication

Entire-Checkpoint: a3b2c4d5e6f7
Entire-Attribution: 73% agent (146/200 lines)
Attribution is calculated by tracking changes at two points:
  1. Before each agent run — Entire captures what you changed since the last checkpoint
  2. At commit time — Entire sums up all your edits and compares them to the agent’s contributions
A typical session looks like:
  1. You write some code
  2. Agent runs, adds more code (checkpoint created)
  3. You edit the agent’s code and add your own
  4. Agent runs again (another checkpoint)
  5. You make final tweaks
  6. You commit
Entire untangles these interleaved contributions to give you an accurate breakdown.