> ## Documentation Index
> Fetch the complete documentation index at: https://docs.entire.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Quickstart

> Get started with Entire by creating your first checkpoint.

This quickstart walks you from installing Entire to creating your first checkpoint: a record of the prompts, transcript, tool calls, and file changes behind an AI-assisted commit.

## Prerequisites

* Git installed and configured
* An AI coding agent installed, such as Claude Code, Codex, Copilot CLI, Cursor, Factory Droid, Gemini CLI, OpenCode, or Pi
* macOS, Linux, or Windows
* Optional: GitHub CLI (`gh`) installed and authenticated, if you want Entire to create and push a private GitHub repository during setup

## 1. Install Entire

Entire ships two release channels:

* `stable`: recommended for most users.
* `nightly`: prerelease builds with newer changes.

Nightly is available through Homebrew and the Linux install script. Scoop currently supports stable only.

<Tabs>
  <Tab title="macOS (Homebrew)">
    ```bash theme={null}
    # Stable
    brew tap entireio/tap
    brew install --cask entire

    # Nightly
    brew tap entireio/tap
    brew install --cask entire@nightly
    ```
  </Tab>

  <Tab title="Linux">
    ```bash theme={null}
    # Stable
    curl -fsSL https://entire.io/install.sh | bash

    # Nightly
    curl -fsSL https://entire.io/install.sh | bash -s -- --channel nightly
    ```
  </Tab>

  <Tab title="Windows (Scoop)">
    ```bash theme={null}
    scoop bucket add entire https://github.com/entireio/scoop-bucket.git
    scoop install entire/cli
    ```
  </Tab>

  <Tab title="From Source">
    ```bash theme={null}
    go install github.com/entireio/cli/cmd/entire@latest
    ```
  </Tab>
</Tabs>

Verify the installation:

```bash theme={null}
entire version
```

## 2. Create a Demo Project

```bash theme={null}
mkdir entire-demo
cd entire-demo
```

<Note>
  Already in a Git repository? Skip this step and run the remaining commands from the repository root.
</Note>

## 3. Enable Entire

Choose the agent you already use. This example uses Codex; replace `codex` with your agent from the table below.

```bash theme={null}
entire enable -y --agent codex
```

| Agent         | Setup flag                | Start command |
| ------------- | ------------------------- | ------------- |
| Claude Code   | `--agent claude-code`     | `claude`      |
| Codex         | `--agent codex`           | `codex`       |
| Copilot CLI   | `--agent copilot-cli`     | `copilot`     |
| Cursor        | `--agent cursor`          | `cursor`      |
| Factory Droid | `--agent factoryai-droid` | `droid`       |
| Gemini CLI    | `--agent gemini`          | `gemini`      |
| OpenCode      | `--agent opencode`        | `opencode`    |
| Pi            | `--agent pi`              | `pi`          |

This installs Git hooks that capture checkpoints when you commit and installs hook configuration for your selected agent. It also creates a `.entire/` directory for project and local settings.

For shared projects, commit `.entire/settings.json` and `.entire/.gitignore`. See [Project and local files](/cli/configuration#project-and-local-files) for what can stay local.

<Note>
  Because this starts in a new folder, `entire enable -y` initializes Git and creates an initial commit. If `gh` is installed and authenticated, Entire can also create a private GitHub repository and push the initial commit.
</Note>

## 4. Start an Agent Session

Start the agent you selected:

```bash theme={null}
# Example with Claude Code
claude

# Example with Codex
codex

# Example with Copilot CLI
copilot

# Example with Cursor
cursor

# Example with Factory Droid
droid

# Example with Gemini CLI
gemini

# Example with OpenCode
opencode

# Example with Pi
pi
```

Prompt it to make a small change:

```text theme={null}
Create a file named hello-entire.md with a short note explaining that this repo is my first Entire checkpoint demo.
```

When the agent finishes, exit the agent session if needed.

## 5. Commit the Change

Check what changed:

```bash theme={null}
git status
```

Then commit it:

```bash theme={null}
git add hello-entire.md
git commit -m "Add first Entire demo file"
```

Because Entire detected recent agent work, it may ask whether to link this commit to the session context:

```text theme={null}
Entire: Active Codex session detected
  Last prompt: Create a file named hello-entire.md with a short note...

Link this commit to session context?
  [Y]es / [n]o / [a]lways (remember my choice):
```

Press `Enter` or type `y` to link the commit. After the commit succeeds, you have created your first checkpoint.

<Note>
  If you choose `always`, Entire remembers that preference and links future matching commits automatically.
</Note>

## 6. View Your First Checkpoint

```bash theme={null}
entire checkpoint list
```

You should see the checkpoint linked to your commit.

Entire stores permanent checkpoint data on a Git branch named:

```text theme={null}
entire/checkpoints/v1
```

Your working branch stays clean. Entire does not add extra commits to it.

## 7. Optional: Push Your Code and Checkpoint

If your repository has a remote, push your code:

```bash theme={null}
git push
```

Entire's pre-push hook also syncs checkpoint data to `entire/checkpoints/v1`.

<Note>
  Checkpoint data can include session context. If your repository is public, pushed checkpoint history is public too. See [Security & Privacy](/security) and [Checkpoint Remote](/cli/checkpoints#checkpoint-remote).
</Note>

## What's Next?

<CardGroup cols={2}>
  <Card title="Glossary" icon="book-open" href="/glossary">
    Learn the terms used across Entire
  </Card>

  <Card title="CLI Commands" icon="terminal" href="/cli/commands">
    Explore all available CLI commands
  </Card>

  <Card title="Checkpoints" icon="chess" href="/cli/checkpoints">
    Learn how Entire captures your sessions
  </Card>

  <Card title="Agents" icon="plug" href="/agents/overview">
    Set up your AI coding agent
  </Card>
</CardGroup>