29 terms
| Glossary term | Definition |
| -------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Agent** | An AI coding assistant connected to Entire, such as [Claude Code](/agents/claude-code), [Codex](/agents/codex), [Cursor](/agents/cursor), [Factory](/agents/factory-droid), [Gemini CLI](/agents/gemini-cli), [GitHub Copilot CLI](/agents/copilot-cli), [OpenCode](/agents/opencode), or [Pi](/agents/pi). |
| **Agent run** | One execution of an agent inside a session. Entire compares your work before each run with the agent's changes so line attribution can stay accurate. |
| **Checkpoint** | A save point for your work. Entire creates checkpoints around agent activity and links committed checkpoints to Git commits. |
| **Checkpoint ID** | A 12-character hexadecimal identifier for a checkpoint, such as `8a513f56ed70`. You can find checkpoint IDs in the CLI and Entire.io. |
| **Checkpoint linking** | The connection between a Git commit and the Entire checkpoint that captured the session context behind it. |
| **Checkpoint remote** | A Git remote used to store checkpoint metadata separately from your code remote. By default, Entire pushes checkpoint metadata to your code remote. |
| **Checkpoints branch** | The permanent Git branch where Entire stores checkpoint and session metadata. The branch is named `entire/checkpoints/v1`. |
| **Commit trailer** | Structured metadata appended to a Git commit message. Entire uses trailers such as `Entire-Checkpoint` and `Entire-Attribution`. |
| **Committed checkpoint** | A checkpoint permanently linked to a Git commit and stored on the checkpoints branch. |
| **Dispatch** | A markdown summary of recent agent work across one or more repositories, branches, and time windows. |
| **Entire CLI** | The command line tool that records sessions, creates checkpoints, links commits, and syncs metadata. |
| **Entire.io** | The web application for browsing repositories, sessions, checkpoints, dispatches, and agent activity captured by Entire. |
| **Entire Repository** | A Git repository stored in EntireDB, Entire's distributed Git database. Creating a [mirror](/guides/repositories/mirrors) stores a synced copy of an existing GitHub repository on the same network. |
| **Entire-Attribution** | A commit trailer that records how much of a commit came from the agent versus a human. |
| **Entire-Checkpoint** | A commit trailer that records the checkpoint ID associated with a commit. |
| **Line attribution** | Entire's calculation of how many changed lines in a commit were written by the agent and how many were written by a human. |
| **Metadata** | Structured data Entire records about sessions and checkpoints, including timestamps, agent type, token usage, attribution, and configuration. |
| **Mirror** | A synced, read-optimized copy of a GitHub repository, hosted on Entire's Git network in a chosen region. The repository stays on GitHub, while the mirror provides an `entire://` remote that agents, automation, or selected users can clone from, fetch from, and push through. |
| **Nested session** | A child session created when an agent spawns another agent or sub-agent during the same body of work. |
| **Rewind** | Restoring your worktree to an earlier checkpoint during an active session. |
| **Semantic Search** | Search indexed Entire history by phrase, meaning, or agent context to find related checkpoints, sessions, and commits. |
| **Session** | A complete interaction with an AI coding agent from start to finish. Sessions include prompts, responses, code changes, checkpoints, token usage, metadata, and line attribution. |
| **Session branch** | A Git branch used to store captured session data without adding commits to your working branch. |
| **Session context** | The prompts, responses, tool activity, code changes, and metadata that explain what happened during a session. |
| **Shadow branch** | A temporary local branch used to store checkpoints during active sessions. Shadow branches are named like `entire/No glossary terms match your filter.
# Capture Checkpoints Source: https://docs.entire.io/guides/checkpoints/capture-checkpoints Learn how Entire turns agent work into committed checkpoints. Entire captures session context while you work, then creates a committed checkpoint when that context is linked to a Git commit. ## How capture works Checkpoint capture has two parts: 1. [Agent hooks](/agents/overview) collect session context, including prompts, transcript, tool activity, changed files, and token usage when available. 2. Git hooks link that captured context to a commit by adding an [`Entire-Checkpoint` trailer](/glossary#entire-checkpoint). After the commit, Entire stores checkpoint metadata on the [`entire/checkpoints/v1` branch](/security#where-your-data-lives). Your working branch stays clean. ## Set up capture for an agent For a new repository, enable Entire with the agent you use: ```bash theme={null} entire enable --agent AGENT ``` For a repository where Entire is already enabled, add another agent: ```bash theme={null} entire agent add AGENT ``` You can see the supported built-in agents in [Agents](/agents/overview), or run: ```bash theme={null} entire agent list ``` ## Commit after agent work To capture agent-assisted work in a checkpoint: 1. Start your agent from an Entire-enabled repository. 2. Ask the agent to make a change. 3. Stage and commit the change with Git. ```bash theme={null} git add . git commit -m "Describe the change" ``` If Entire detects recent agent work, it may ask whether to link the commit to the session context. Choose `yes` to create the checkpoint. Choose `always` if you want Entire to remember that preference for future matching commits. ```text theme={null} Entire: Active Codex session detected Last prompt: Add a user settings page... Link this commit to session context? [Y]es / [n]o / [a]lways (remember my choice): ``` ## Link future commits automatically When the "Link this commit to session context?" prompt appears during `git commit`, choosing `yes` or `no` only applies to that one commit. To link future matching commits in this repository without being prompted during `git commit`, set `commit_linking` to `always`. Set `commit_linking` in one of these files: * `.entire/settings.local.json` if this preference should only apply to you * `.entire/settings.json` if this should be the team setting for the repository ```json theme={null} { "commit_linking": "always" } ``` ## Let the agent commit Your agent can also create commits for you. For example, you might ask it to make a focused change and commit when it is done. Entire still uses the Git hooks to link the commit to the captured session context. If the agent makes several commits in one session, each commit gets its own checkpoint. ## Capture multiple commits from one session A single agent session can produce multiple checkpoints. This happens when a long session creates several commits, or when you split the agent's work into smaller commits yourself. Each commit gets its own checkpoint ID. The checkpoints can share the same session context so you can still inspect the prompts, transcript, and work that led to each commit. ## Capture one checkpoint from multiple sessions One checkpoint can also include more than one session. This happens when several agent sessions contribute to the work before you make a single commit. In Entire.io, those sessions appear together inside the checkpoint's Sessions tab. The checkpoint diff shows the combined change, while [session details](/guides/sessions/sessions-in-entire-io) show the context behind each contribution. ## What does not create a checkpoint Entire needs captured session context and a Git commit to create a normal committed checkpoint. A checkpoint may not appear when: * Entire has not been enabled in the repository * agent hooks were not installed for the agent you used * the agent did not change files in the repository * no commit was created * a GUI Git client could not find the `entire` command from its Git hooks If a checkpoint is missing or did not link where you expected, see [Troubleshooting](/guides/checkpoints/troubleshooting). # Keep Checkpoints Local Source: https://docs.entire.io/guides/checkpoints/keep-checkpoints-local Capture checkpoint history without pushing it to a remote repository. When checkpoint history should stay on your current machine, disable automatic checkpoint pushes in local settings: ```bash theme={null} entire configure --local --skip-push-sessions ``` Entire will still capture checkpoint data on your machine, but it will not push that data to GitHub or another remote. This is useful for local experiments or repositories where you do not need checkpoint history available from another device. The tradeoff is that teammates cannot review local-only checkpoints unless you share them another way. This writes `push_sessions: false` to `.entire/settings.local.json`: ```json theme={null} { "strategy_options": { "push_sessions": false } } ``` ## Keep checkpoints local for everyone To disable checkpoint pushes for everyone working in the repository, use project settings instead: ```bash theme={null} entire configure --project --skip-push-sessions ``` This writes the same setting to `.entire/settings.json`. Commit that file when the behavior should apply to the whole project. # Overview Source: https://docs.entire.io/guides/checkpoints/overview Learn what checkpoints are, why they matter, and how Entire captures them. ## What is a checkpoint? A checkpoint is an addressable record of the context behind an AI-assisted change. After you [enable Entire](/quickstart) in a repository, the [CLI](/platforms/cli) uses Git hooks and [agent hooks](/agents/overview) to capture session data as you work. When you or your agent commit, Entire saves that captured context as a checkpoint and links it to the commit. ## Why checkpoints matter * Review agent work without guessing what happened * Trace a commit back to the prompt, transcript, and session that produced it * Understand what changed, why it changed, and who edited what * Search past agent work later ## How checkpoints connect to Git Each checkpoint has a 12-character ID. Entire adds that ID to the commit message with an [`Entire-Checkpoint` trailer](/glossary#entire-checkpoint) and stores checkpoint metadata on the [`entire/checkpoints/v1` branch](/security#where-your-data-lives). Your normal Git history stays clean. Entire does not add extra commits to your working branch. ## What a checkpoint stores A checkpoint stores the available context behind the change, including: * the linked Git commit * the agent session or sessions behind the change * prompts and transcript * tool activity * changed files * token usage, when available * [AI attribution](/guides/sessions/sessions-in-entire-io#files-and-attribution) for the changed lines in the checkpoint ## Where to review checkpoints You can review checkpoints from the CLI or in Entire.io. Use [Review Checkpoints](/guides/checkpoints/review-checkpoints) to choose the right surface and see the common review flows. Use the [CLI reference](/cli-reference/checkpoint) when you need exact command syntax. # Review Checkpoints Source: https://docs.entire.io/guides/checkpoints/review-checkpoints Choose how to review checkpoint context in Entire.io or the Entire CLI. Use this page when you want to inspect what happened behind a checkpoint: the commit, prompt, transcript, sessions, files, token usage, and attribution. ## Choose a review surface | Use this | When you want to | | -------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------ | | [**Entire.io**](/guides/checkpoints/review-in-entire-io) | Browse checkpoints by repository and branch, inspect sessions visually, review file diffs, or share context with a team. | | [**Entire CLI**](/guides/checkpoints/review-in-cli) | Review from a terminal, explain a checkpoint or commit, inspect transcript output, or export JSON. | ## What to look for When you review a checkpoint, check: * the original prompt or task * the transcript and tool calls * files changed by the agent * file diffs and line attribution * token usage and session metadata * whether the checkpoint is linked to the commit you expected ## Continue withBuild with Entire
Entire stores agent sessions, prompts, and tool calls with your commits, so you, your team, and your agents can review what happened, search past work, and start with context.
Start here
Go from install to context-rich commits.
Set up Entire, use your preferred agent, and start saving the context behind agent work.
01
Install Entire
Set up the CLI in your existing Git workflow.
02
Use your preferred agent
Capture work from Codex, Claude Code, OpenCode, Pi, and more.
03
Save context with commits
Store sessions, prompts, tool calls, and checkpoints with your work.
04
Connect a repository
Mirror a GitHub repo so humans and agents can work from Entire.
05
Review the history
Search, inspect, and understand why code changed.
Workflows
What do you want to do?
Concepts
How Entire works
Understand the building blocks Entire uses to capture, search, and review agent work.
Platforms
CLI and Entire.io work together.
Use the CLI to capture and configure work locally. Use Entire.io to inspect, review, and share captured history with a team.
Resources
Looking for something specific?