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 in Github (if you choose to push them to Github). To find your raw session data in 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

The timing of checkpoint creation depends on your strategy:
StrategyCheckpoint Creation
manual-commitWhen you make a Git commit
auto-commitAfter each AI agent response

​
Strategies

Entire supports two strategies for capturing sessions:

​
Manual Commit (Default)

Recommended for most workflows
With manual-commit, Entire captures checkpoints only when you make commits. This keeps your Git history clean while still providing full session capture. Benefits:
  • No extra commits on your branch
  • Safe to use on any branch, including main
  • Full rewind capability during sessions
  • Clean pull request history

​
Auto Commit

With auto-commit, Entire automatically creates commits after each AI agent response. Benefits:
  • Automatic checkpoint creation
  • No manual commits needed during development
Considerations:
  • Creates many small commits (can be squashed later)
  • Best used on feature branches, not main
See Strategies for detailed configuration.

​
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.