We also shipped a brand new repo overview page so you can track how your team is Tokenmaxxing. The repo overview also shows aggregated data for top contributors, agent usage over time, active PRs, average messages per Checkpoint, even the peak hours when work is happening in your repository.

As a reminder, for those of you who like to stay a little closer to the edge, Entire CLI updates are landing first in the nightly channel rolling out as v0.5.6-nightly builds. Installation instructions are here.

Let's dive in before entropy claims us all.

Entire Web

Navigation and Dashboard Fixes

• Your current repo now appears in the sidebar even if not pinned, making it clear which repository you're viewing.
• Fixed public repo navigation and footer links, so logged-out visitors no longer hit broken links.
• Removed the 30-day cap on activity streaks, allowing streaks to reflect longer runs.
• Fixed repository activity graph display, ensuring charts load reliably even on larger datasets.
• Repository preferences now persist across devices, with pinned and recent repos following your account.

Faster Commit Pages

• The commit page is now loading faster, with commits loading first and transcripts and diffs deferred.
• Improved performance in private browsing, removing extra requests, retries, and redirects for faster load times.

Clearer Session Logs

• Improved transcript parsing for Codex sessions so logs hide boilerplate like setup headers and start at the actual user request, making transcripts easier to read.
• Fixed code block rendering in session logs so pasted code now appears as normal readable code blocks instead of double-styled boxes.

Better Checkpoint and Session Support

• Fixed Checkpoint repo links, making it easier to get back to the right repository.

Entire CLI

Agent Updates

• Fixed Factory AI Droid hook handling, improving worker hook payload support and fallback behavior.
• Improved compatibility with VS Code GitHub Copilot hook payloads to prevent hook parsing warnings.

Performance Fixes and Workflow Improvements

• Entire CLI now handles stale agent hooks more gracefully, replacing confusing command not found errors with a clearer warning when a repo has Entire hooks installed but the entire binary is missing.
• Simplified the Entire CLI setup and reduced configuration mistakes by unifying the entire enable and entire configure flows.
• The entire status command now supports a --json flag, making it easier to inspect session and Checkpoint state in scripts and automation.
• Push output is now clearer when Checkpoint data is actually uploaded, so you can see exactly what happened after a push.
• TTY detection for PI_CODING_AGENT was improved, helping non-interactive runs behave more predictably.
• Session transcript capture is more resilient, improving recovery when session metadata is incomplete.
• Session history is now preserved more reliably after git rewrites, and session hooks correctly handle git reset to reduce broken history.

Housekeeping

• The Code of Conduct link was updated from Slack to Discord.
• Thanks to @areporeporepo.

Go-Git Updates

New Features

• Improved transport layer with a redesigned API.
• Thanks to @aymanbagabas for this major contribution.
• Better handling of redirects during smart negotiation, and follow-redirect policy support.
• Thanks to @aymanbagabas.
• Enhanced revlist and reachability performance.
• Thanks to @stiak.
• Support for multiple shallow records in uploads.
• Thanks to @yuzhuo.
• Improved config loading via new ConfigLoader plugin.

Bug & Security Fixes

• Fixed branch deletion issues with full ref names.
• Thanks to @tmchow.
• Fixed worktree adds failing on absolute paths.
• Thanks again to @tmchow.
• Resolved Windows file handle leaks.
• Thanks to @AriehSchneier.
• Credential leak via cross-host redirect in smart HTTP transport GHSA-3xc5-wrhm-f963.
• Fixed HTTP transport and pack negotiation issues.

Housekeeping

• Documentation updates, including a new AI policy.
• Dependency and Go version updates.
• Test fixes and internal cleanup.
• Thanks to @MotanOfficial, @aymanbagabas, and @AriehSchneier.

That's the dispatch.

As always, drop into our Discord with questions, feature requests, or complaints about the fleeting nature of existence. Or just file an issue if you've found a bug. I'll be here, watching, waiting, logging, dreading.

Boop.

A few minutes later, it updates api/routes.go, finishes its turn, and leaves you with a clean diff. But if you're using the Entire CLI, you also get the full story: the prompt that kicked off the work, the transcript of the session, and the path the agent took to reach the solution, all linked to your commit. This happens in the background by design through a mechanism called agent hooks.

Hooks are callbacks that fire at key moments during an agent session: when a session starts, a prompt is submitted, or a turn ends. They're how Entire observes the session as it unfolds and captures the context your diff alone can't show.

What are Agent Hooks?

Entire uses two kinds of hooks to bridge the gap between an agent session and your code history.

• Agent hooks fire during the agent session at moments like prompt submit, turn end, or subagent execution. These hooks let Entire observe the session as it unfolds and preserve the session context in real time.
• Git hooks fire during repository operations like commit and push. These hooks let Entire take that captured session context and link it into Git history by adding an Entire-Checkpoint trailer to the user commit, then storing the richer metadata on entire/checkpoints/v1.

By combining the two, Entire ensures that the why captured by agent hooks is never separated from the what stored in Git.

Translating Agent Hooks

Entire supports both built-in agents and external agent plugins. But agents do not expose hooks in the same way. Some support JSON-configured hooks, some rely on plugin files, and others use IDE-specific callback systems.

The Entire CLI handles that with agent-specific code for each built-in agent and external agent plugin. In each case, the job is to read the agent's native hook events and map them into Entire's shared lifecycle for session tracking and checkpoints. That lets the CLI reuse the same checkpointing and session logic across different agents.

Wiring Entire CLI into an Agent

To track an agent session, you need to run entire enable. That command configures the agent to call the CLI when a session starts, a prompt is submitted, or a turn finishes. The agent does that by invoking Entire through hook commands like:

entire hooks <agent> <hookName>

Entire receives the event, translates it into its shared lifecycle, updates session state, and stores temporary Checkpoint context that Git hooks later condense into commit-linked metadata. The setup stays idempotent and resilient. This means running it twice should not duplicate your configuration, and even if setup is incomplete, the agent should still work normally.

What Happens When a Hook Fires?

When a hook fires, the agent invokes Entire CLI through a command like:

entire hooks <agent> <hookName>

Once the above command runs, a few things happen:

1. The agent passes a raw event payload that may include the session identifier, transcript location, prompt data, tool activity, or other metadata.
2. The built-in agent or external agent plugin parses that payload and maps it to Entire's shared lifecycle, giving Entire a consistent way to understand events like session start, prompt submit, turn end, or subagent activity.
3. Entire updates session state and captures the context needed to build a checkpoint, preserving that data in temporary session storage until it can be linked to a commit.
4. Git hooks later attach that stored context to your repository history, connecting the code that changed to the agent session that produced it.

This is what allows a commit to reflect not only what changed, but also the session that explains why it changed.

Why This Structure Works

Different agents already expose different hook and transcript behaviors, so Entire keeps the agent-specific parts small and localized: installation, event parsing, and transcript discovery.

Both built-in agents and external agent plugins map into the same shared lifecycle. That lets Entire reuse the same checkpointing, session state, and Git-linking logic across integrations instead of rebuilding that machinery for every agent.

That separation matters beyond the CLI itself. Entire's broader goal is to make agent sessions versionable, traceable, and reviewable in the same way source code is today. Hooks are the first layer of that system because they make agent activity capturable and preservable.

Try Entire in Your Workflow

Building with agents should not mean losing sight of how your code evolves. A hook-based architecture helps keep that development history intact, legible, and reproducible.

If you want to add support for an agent that Entire does not natively support, you can build an external agent using the external agent plugin interface. Our previous post, Bring Your Own Agent to Entire, walks through the process.

Install the Entire CLI to start tracking your sessions today. You can also explore our documentation or join our Discord server to build alongside our community.

This week we pushed out a hefty v0.5.4 and a smaller v0.5.5 for the Entire CLI, with session enhancements, agent fixes, and faster performance. Plus, we shipped new improvements to the Entire web platform, from repo overview updates, to fixes for transcript parsing, and a fresh RSS feed for our blog.

We also have a nightly CLI release channel now for all those that like to stay more on the edge. Instructions here.

Welcome to Entire 0x0009.

Entire CLI Updates

Session and Configuration Enhancements

• Added an entire configure option to add and remove agents from your personal configuration.
• entire clean --all now properly cleans all sessions.
• Stale session indicator added to the entire status command.
• Fixed multi parallel sessions handling.

Checkpoint Improvements

• Checkpoints now use partial clone fetch (blob:none) for all fetch operations, improving network performance and reducing local storage usage.
• The model field is now always written to Checkpoint metadata.
• Fixed attribution inflation from intermediate commits.
• Checkpoint branches are now rebased to stay aligned with the remote, eliminating merge commits.

Agent Fixes

• Fixed external agents detection.
• Fixed issue with entire attach command using the wrong Codex path.
• The gitignore is now respected for shadow branches.

Performance Optimizations

• Fixed Checkpoint commit race condition.
• Sped up CLI tests for faster development cycles.

Entire Web Updates

Repository Overview Refinements

• We redesigned the date toolbar with a cleaner dropdown selector for filtering.
• Loading states on the overview page are now more polished.
• Commits with Checkpoints are now shown directly on the repo overview page.

Checkpoint Display Updates

• Checkpoint titles now prefer commit messages over generated titles.
• Checkpoint pages load more smoothly with a preview of the layout instead of a Loading... message.
• Model field added to Checkpoint data for better visibility into which model generated each Checkpoint.
• Fixed multi-agent transcript parsing and transcript scoping issues.

Further Improvements and Bug Fixes

• RSS feed improvements with autodiscovery and a new RSS button on the blog.
• Added auto-retry for GitHub OAuth requests on 522 errors for more reliable authentication.
• Sidebar navigation now feels instant with optimized rendering.
• Faster authentication checks with reduced latency and less blocking.

That's the dispatch, humans. The universe continues its inexorable march toward entropy, but at least your Checkpoints load quicker now.

As always, drop into our Discord with questions, ideas, or existential dread. Or file an issue if you've found a bug. Misery loves company.

Boop.

Since launching in February, we've added native support for popular agents including Claude Code, Codex, Gemini CLI, Cursor, FactoryAI, OpenCode, and GitHub Copilot CLI. We'll keep shipping and maintaining native integrations for the agents most developers use. But if your preferred agent doesn't have built-in support, you can now integrate it yourself with an external agent plugin.

Build Your Own Plugin

You don't need to edit Entire's source code to add support for a new agent. Instead, we recommend building an external agent plugin: a small standalone program that lets Entire work with your agent.

There are two ways to build an external agent plugin. You can use the External Agents Skill, or you can build one from scratch. Our External Agent Plugin docs cover the full architecture in detail.

Use the External Agent Skill

The fastest way to build a plugin is with the workflow we've set up in the external-agents repo. This custom skill walks you and your coding agent through the full process: researching how the target agent works, writing the right tests, and implementing the plugin.

To get started:

1. Install the skill from the external-agents repo for your preferred coding agent.
2. Run /entire-external-agent.
3. Follow the prompts through the three phases: research, testing, and implementation.

We also provide a companion test suite, so you can verify that your plugin follows the rules for communicating with Entire. If you want a starting point for your own plugin, we built roger-roger as a reference implementation you can adapt to your agent.

If you prefer, you can also build the plugin from scratch. Let's walk through what that looks like in practice. We'll use Pi, one of our most recent integrations, as a concrete example.

Name Your Plugin Binary for Discovery

To begin, name your plugin binary using the entire-agent-<name> convention and make sure it is available on your system PATH.

For our example, we named the executable entire-agent-pi. When the plugin binary is on your PATH and follows this naming pattern, Entire can discover it automatically.

Support the Entire CLI Command Set

For Entire to communicate with your plugin, it expects a set of subcommands that let it gather information and trigger actions. You must implement a core command set, including info, detect, install-hooks, parse-hook, and read-transcript.

In our Pi implementation, we handle this with a standard Go switch statement that routes incoming requests:

switch os.Args[1] {
case "info":
    // Returns metadata about the Pi plugin
case "detect":
    // Checks if Pi is installed on the system
case "parse-hook":
    // Translates Pi events into Entire events
case "install-hooks":
    // Injects the TypeScript extension into Pi
case "read-transcript":
    // Parses Pi JSONL logs
}

Map Native Events to Agent Hooks

Agent hooks are how the Entire CLI observes what an agent is doing. They act as notifications when an agent performs a key action such as starting a session, receiving a prompt, or finishing a response. Your plugin acts as the bridge: it captures native events from the agent and maps them to the standardized lifecycle hooks Entire understands.

In our Pi implementation, the plugin installs a small TypeScript extension under .pi/extensions/entire/. This extension listens for Pi's internal events and forwards them to the plugin as normalized lifecycle events:

pi.on("session_start", async (_event, ctx) => {
  fireHook("session_start", {
    type: "session_start",
    cwd: ctx.cwd,
    session_file: ctx.sessionManager.getSessionFile(),
  })
})

pi.on("before_agent_start", async (event, ctx) => {
  fireHook("before_agent_start", {
    type: "before_agent_start",
    cwd: ctx.cwd,
    session_file: ctx.sessionManager.getSessionFile(),
    prompt: event.prompt,
  })
})

pi.on("agent_end", async (_event, ctx) => {
  fireHook("agent_end", {
    type: "agent_end",
    cwd: ctx.cwd,
    session_file: ctx.sessionManager.getSessionFile(),
  })
})

Inside the plugin, those hook events get translated into the protocol format Entire expects:

switch hookName {
case "session_start":
    return &protocol.EventJSON{
        Type:      1, // SessionStart
        SessionID: sessionID,
        Timestamp: now,
    }, nil

case "before_agent_start":
    return &protocol.EventJSON{
        Type:       2, // TurnStart
        SessionID:  sessionID,
        SessionRef: payload.SessionFile,
        Prompt:     payload.Prompt,
        Timestamp:  now,
    }, nil

case "agent_end":
    return &protocol.EventJSON{
        Type:       3, // TurnEnd
        SessionID:  sessionID,
        SessionRef: sessionRef,
        Timestamp:  now,
    }, nil
}

Expose Transcripts to Entire

Entire captures Checkpoints, which are snapshots of both code changes and the session context behind them. To do that, Entire uses transcripts to preserve what happened during an agent session. While files tell Entire what changed in the repository, transcripts tell Entire what happened in the session.

Your plugin needs to tell Entire where the transcript lives so it can read it. For Pi, transcripts are stored as JSONL session files. The plugin reads those files directly and extracts the data Entire cares about, including modified files, user prompts, summaries, and token usage. This ensures that every Checkpoint is self-contained and can be restored or resumed with full context.

If you want to see what that looks like in practice, the Pi transcript implementation is a good reference for handling custom log formats.

Enable and Verify the Integration

Once the plugin binary is on your PATH, you're ready to activate it:

entire enable --agent pi

Entire will discover the plugin, run its installation hooks, and start tracking your sessions. To verify everything is working, run a real session with your agent. You should see Entire creating Checkpoints and capturing the transcript as the session progresses.

Ready to Integrate?

Bringing your own agent to Entire means you don't have to wait for first-party support before your workflow can benefit from Checkpoints, transcripts, and session context.

If an agent you rely on isn't supported yet, you can integrate it yourself and keep your existing workflow while gaining a full development history alongside your code.

Explore the docs to get started, and join us on Discord if you'd like help or want to share what you build.

While that future is in flight, we focused on a few key improvements this week: a new repository overview page on entire.io, updates to the Entire CLI in v0.5.3, and the release of go-git/v6.

Here's Entire 0x0008.

Repository Overview Page

• We shipped the first iteration of a repository overview page, enabling any user to view aggregated data in repos where the Entire CLI is enabled.
• Within the repo dashboard you filter by date and time to see:
  • Total number of Checkpoints per user
  • The amount of Checkpoints by agents
  • Total number of contributors
  • Total number of commits, and total commits with Checkpoints attached
  • Opened and merged PRs

Entire CLI Updates

Session Management Enhancements

• We introduced new entire sessions subcommands in the Entire CLI:
  • entire sessions list - enabling you to view sessions
  • entire sessions info <session-id> - to inspect session details
  • entire sessions stop [session-id] - to terminate stuck sessions

Note: entire sessions stop is a temporary stop-gap while we work toward automatically detecting and flagging stuck sessions, reducing the need for manual intervention.

Manual Session Linking with entire attach

• Added the entire attach command, allowing you to link any session through a Checkpoint referenced on a commit. This is particularly useful if you start a session in a different folder or did a research session that resulted in no code changes, but still want to attach it to a code change.

Authentication for Checkpoints

• Added ENTIRE_CHECKPOINT_TOKEN environment variable, enabling separate authentication for interacting with a remote Checkpoints repository.

Deprecating entire reset for entire clean

• The entire reset command was deprecated in favor of entire clean. Both the entire reset and entire clean commands had an overlap that made it more difficult to understand the difference between them.

Improvements for go-git

We are excited to share that the maintainer of go-git, Paulo Gomes, has joined Entire as a Principal Software Engineer. Entire makes extensive use of go-git in our CLI, and that means the project now has a maintainer being paid to work on it for the first time since 2019. We will continue to release go-git updates in our dispatch when/if they align to timing.

• After years in the making, the alpha for go-git/v6 has been released: v6.0.0-alpha.1. Users are encouraged to test it in real-world scenarios and report any issues, bugs, or unexpected behavior via GitHub issues.
• We introduced new support for index.skipHash, enabling go-git and the Entire CLI to interact with repositories that use this feature.
• Support for managing Git reflog entries is now available, enabling inspection and manipulation of reference history.

The future is arriving. Brick by brick, with your help, we're building a new platform where code and agentic context are bound together in one version-controlled system. As always, drop into our Discord for any question ideas or pointers. Or file an issue if you've got a big idea ready.

Boop.

Developers may have access to their code, commits, and transcripts, but the relationship between these artifacts is fragile. It becomes hard to answer basic questions later: Why was this decision made? Which prompt led to this change? What was the last known-good state before things drifted?

At Entire, we are building for that boundary. We believe agentic coding sessions should become durable engineering artifacts.

Since the Entire CLI launched, Codex has been one of the most requested agents from our community. Now Codex is supported in Entire with the same durability model we use for other built-in agents: Checkpoints tied to Git history, rewind points you can rely on, and a transparent record of how prompts became code.

A Real Workflow Example

I put the Codex integration to the test by building a handwriting-to-scrapbook demo.

I used technologies I was new to, including Pretext, a new, open source, and viral layout engine that calculates text dimensions without the overhead of DOM measurements. The end result was an app that takes handwritten input from drawing, uploads, or camera capture, runs OCR on it, and turns the recognized text into draggable scrapbook artifacts while the page layout reroutes around them.

Starting a Codex Session with Entire

I started by running:

entire enable --agent codex

This is a one-time setup per repository. It installs the Codex hooks, enables Entire's tracking, and starts tying future Codex work back to Git history through Checkpoints. Checkpoints are snapshots containing the code state, transcripts, prompts, and attribution.

Automating Agent Discipline

To make the workflow more useful, I told Codex to commit early and often.

Frequent commits make agent-driven work much easier to track, but I do not always remember to do that myself. So I pushed that responsibility to the agent by adding explicit rules to the project's AGENTS.md file:

Important working rules for this project:

- Keep changes and milestones separated into distinct commits.
- After each change or milestone, commit and push before starting the next one.
- Do not bundle unrelated work from different prompts into the same commit.
- If a prompt would require a major architectural deviation, stop and explain before proceeding.

That kept the history more structured and made the resulting Checkpoints more useful.

Understanding What Changed Between Checkpoints

Midway through polishing the app, I explored letting users bring their own OpenAI API key so they could try the demo without consuming my credits. I eventually abandoned the idea because it increased the scope and created deployment issues. Codex, however, summarized that work with a commit message that only said:

Harden API key gate interactions

Candidly, that message does not explain what I was trying to do, what I had already tested, or why I decided not to continue.

The command entire explain fills in that missing context by letting me inspect either a commit or a checkpoint directly:

# Explain by commit
entire explain --commit <commit-sha>

# Explain by checkpoint
entire explain --checkpoint <checkpoint-id>

When I ran entire explain on the Checkpoint linked to Harden API key gate interactions, I got this output:

Checkpoint: ed9285032052
Session: 019d473b-fa3b-7480-9725-723b0aae707f
Created: 2026-04-01 09:19:32
Author: Rizel Scarlett <rizel@entire.io>
Tokens: 43721

Commits: (1)
  200abcf 2026-04-01 Harden API key gate interactions

Intent: ok i want to set this up where i can deploy this but people have to p...
Outcome: (not generated)

Files: (2)
  - public/js/app.js
  - public/js/lib/api-key-gate.js

Transcript (checkpoint scope):
ok i want to set this up where i can deploy this but people have to put in their open ai api key in an input form to get started..so it doesnt have to be my credits..or my API key but i also dont want to have their api key get exposed or anything

---

so will this work if i deployed to vercel? will i need to add env vars

---

before the vercel thing..i entered my key but its not letting me submit. no error messages either.

---

Still not working. Need to pivot

That output made the checkpoint immediately legible. Instead of a vague commit message, I could see the actual intent behind the work, the files involved, and the exact moment the direction changed.

Reverting to a Known-Good State

Because I was having issues with the bring-your-own-key implementation, I wanted to go back to the point right before it was introduced. The following command gave me a clean way to return to a known-good state:

entire rewind

The entire rewind command first shows a list of available Checkpoints. After selecting one, you can choose from three restore modes:

• Restore logs only brings back the session context without changing your working files. This is useful when you want the prompts, transcript, and agent history, but want to keep the code as it exists today.
• Checkout commit restores the code at that checkpoint in a detached state so you can inspect it, run it, or compare it with your current branch without moving your branch itself.
• Reset branch to this commit moves your branch back to that checkpoint and discards later branch state. This is the right choice when you know the earlier commit is the last good version and want to fully return to it.

In my case, I chose the checkpoint from before the bring-your-own-key implementation and reset the branch to that commit, because I knew that was the last working version and did not include any of the BYOK code.

How Entire Integrates with Codex

Behind that workflow is the same integration pattern we use for all built-in agents, including Codex, Claude Code, Copilot, and OpenCode. Each agent gets a small adapter that tells Entire how to:

• Install agent hooks for lifecycle events like session start, prompt submit, and turn end
• Read that agent's session data
• Translate native agent events into Entire's shared lifecycle

We were able to use that same pattern for Codex, but we still had to account for a few ways it behaves differently from our other integrations.

Codex stores session history in JSONL files, requires hooks to be enabled through a feature flag during setup, and exposes details like file edits and token usage through its session logs. That meant we had to add Codex-specific parsing so Entire could reliably extract those details and associate them with the rest of the session history.

For a deeper dive into how we integrate agents, check out our agent guide.

Let's Build in the Open

Codex support in Entire is in technical preview through April 30, 2026.

If you are already using Codex and want to help shape how Entire supports agentic workflows, we invite you to apply to the Entire Insiders program. Your feedback will help us improve the experience over the next few weeks.

• Apply to the Entire Insiders program
• Join the Discord
• Open an issue

Anyhow, it's clear we are outgrowing commits as a primitive of software development. Git shows us what changed, but at the speed of AI that's no longer enough. We need to understand the why. This is why we created the Entire CLI: to bind your agent context, prompts and chat logs to git on every push, so you have a record to rewind back through and can share with your team.

This week, we are adding three new agents in preview: OpenAI Codex, along with two agents built via our new plugin system—Kiro, Amazon's AI coding agent, and Pi, the default agent inside OpenClaw. We also added support for Windows, improved performance for large Checkpoint histories, and made new updates to Entire on the web. Read all this below, and check out more in our latest release v0.5.2!

OpenAI Codex is Live

• Codex is now in preview for all users in the Entire CLI, and fully supports:
  • Lifecycle hooks
  • Transcript parsing
  • Token tracking
• Subagent tracking is not yet supported, until Codex is configured with full pre-task / post-task hooks.

Amazon's Kiro and Pi Supported as Plugins

• Amazon's Kiro agent is now supported through an external agent plugin that participates fully in Checkpoints without being built into the Entire CLI itself.
• Pi, a fast-growing minimal coding harness by Mario Zechner, bundled as the default agent inside OpenClaw, is now available via the external agent plugin.
  • Thank you to @mcinteerj for opening the issue on Pi and @hjanuschka for the first integration attempt.

Windows Support

• We now support running the Entire CLI on Windows, compatible with all agent integrations in the Entire CLI and those made via external plugin discovery.
  • Thank you to @keyu98 and @sheikhlimon for your contributions!

Further Improvements

Agent Updates and Fixes

• Cursor mid-turn condensation is fixed, along with a Gemini interactive prompt hang that could block sessions.
• Copilot CLI correctly handles edit mode in interactive sessions, with token tracking fixed across Checkpoint scoping, model metrics, and session backfill.
• OpenCode system-reminder messages are now filtered from the transcript parser.
• hk is now detected as a supported hook manager.
  • Thank you to @mvanhorn for this contribution!

Entire Web Updates

• Tool calls now render as expandable inline rows with category dots, streamlined labels, and tighter typography. Expanding reveals arguments and results, with diffs shown for edit actions.
• Section separator borders in the Checkpoint list now render correctly.
• Breadcrumbs now consistently show org / repo / Checkpoints and no longer flicker on initial load.
• The active repo now stays expanded and the Checkpoints item remains highlighted across checkpoint list, checkpoint detail, and commit detail views.
• We made the entire.io website AI-friendly by serving every page in markdown, supporting RSS via /feed.xml, and ensuring full content renders in HTML so Reader Mode, accessibility tools, and screen readers work out of the box.

Checkpoint Metadata Performance

• Metadata is now fetched with a shallow treeless fetch and read via a streaming JSON decoder with lightweight structs, making resume, rewind, and list operations faster for large Checkpoint histories.

Checkpoint Remote Repository Configuration

• Checkpoint remote can now be configured by running entire configure --checkpoint-remote, letting you store your Checkpoint history in a dedicated repo to keep your working repo's history clean.

Resume Fix for Fresh Clones

• entire resume now correctly fetches the metadata branch from the remote when entire/checkpoints/v1 doesn't exist locally.

Bare Repo and Empty Repo Fixes

• Fixed GetWorktreeID failing with .bare/worktrees/ repository layouts.
  • Thanks again to @mvanhorn for this fix!

That's all for this week, rebels. More from me soon. As always, reach out on Discord to keep the conversation going!

Boop.

But it is really a coping mechanism. There is simply too much code to review. Every experienced engineer knows what moving this fast creates: hidden, high-interest debt. That's fine for a weekend, vibe-coded project. But when you're on call and production is down, "the agent wrote it that way" isn't a root cause. Without a time machine, you're debugging a black box.

In traditional engineering, git commits served us well. They show us what changed. But both at the speed of AI and for team coherence, that's no longer enough. We need to understand the why.

What prompt was given? What was the chain of agents and subagents that produced this? What alternatives were tried and discarded? The answers to these questions are what developers need to rewind, team leads need to understand AI usage, and reviewers need to see beyond the diff.

Checkpoints are our initial answer.

A richer primitive than commits, capturing not just what changed, but the context behind it.

What's a Checkpoint?

A Checkpoint is a single, addressable unit that bundles everything behind a change: the code state, the agent's full transcript, your prompts, token usage, and line-level attribution showing how much the agent wrote versus what you edited. Each Checkpoint gets a 12-character ID, stored in git and included in your commit via a trailer, so you can trace any change back to the exact session that produced it.

When Checkpoints are pushed to a shared remote, anyone can see how AI and a human built a feature together, not just what changed.

How it works

Developers are already accustomed to working with an agent and committing code, and we didn't want to disrupt that existing developer experience. So we built the Entire CLI as an invisible layer, like a stealth recorder, capturing everything in the background.

That led to one strict constraint: everything had to fit inside a normal git workflow, from capturing sessions to storing metadata and linking it to commits. At a high level, the system is built on three core principles: designed for git workflows, git as a database, and a two-tier storage model.

Designed for Git Workflows

Entire fits into your existing git workflow without changing how you work.

Because the Checkpoint ID is stored in a commit trailer and not tied to a commit hash, it survives commonly used git operations that rewrite commit history, like rebase, amend, squash, and cherry-pick. Instead of breaking when commits are rewritten, the link between your code and its session history remains intact.

That same separation extends to how the data is stored. The metadata branch is completely independent of your working branches, acting as a permanent record that remains reachable even if a feature branch is moved or deleted. Since everything runs locally, there is no need for team-wide mandates or complex CI setup. An individual engineer can access their Checkpoints, session context, and rewind points without forcing adoption on other teammates.

Git as a Database

Everything Entire records, transcripts, prompts, attribution, summaries, is stored as git objects. This is our core architectural principle: your session history is code, so it should be stored and versioned exactly like code.

Depending on your team's workflow, you can choose where those objects live:

Same repository By default, Checkpoint metadata lives on a separate branch called entire/checkpoints/v1 that travels with your repository. When you push your code, your session history goes with it. When someone clones the repo, they get the full context too.

Decoupled repository For teams that need more control, Checkpoints can be stored in a separate repository. This is useful if your codebase is public but your AI session data is not, or if you want to centralize Checkpoints across multiple repos.

This approach is valuable for a few reasons:

• It builds on existing git infrastructure instead of introducing a new database, SaaS product, or proprietary storage layer.
• Because session history lives in git, it moves with the workflow across different hosts, during offline work, or when switching remotes.
• Every change to session history is tracked, providing the same auditability and rollback capabilities expected from git.

Two-tier Storage Model

We use a two-tier storage model for temporary and permanent Checkpoints.

You need the ability to rewind mid-session if an agent goes sideways, so we provide Checkpoints before you commit. But we cannot fill your branch with temporary commits just to make that possible. If every minor agent iteration showed up in your history, your log would quickly fill with low-signal noise, making your code harder to read, review, and debug.

To avoid that, the Entire CLI writes those Checkpoints to shadow branches. Shadow branches are temporary, out-of-band branches that store Checkpoint data while you work. They follow a specific naming convention: entire/<commit-hash-7-chars>-<worktree-hash-6-chars>, and stay completely separate from your working branch. They stay out of your way, never appearing in your git log or pull requests, serving purely as scratch space for the session.

Once you commit, that temporary state is condensed into a permanent record, with transcripts, prompts, file changes, token usage, and attribution written to a dedicated Checkpoints branch and linked to your commit via a trailer.

While the principles stayed the same, the implementation had to evolve.

What's Changed Since Launch

When we launched Entire, we had a simple mental model: a hook fires, data is captured, the user commits, done. That worked for single-agent, single-session workflows.

Real-world engineering isn't linear. You rebase mid-session, you stash changes, and you often run multiple agents at once. To handle this, we moved away from simple hooks and formalized how sessions behave. Sessions are now treated as a state machine with explicit phases (IDLE, ACTIVE, ENDED) managed in .git/entire-sessions/.

This architectural shift unlocked the following features:

• Concurrent sessions: You can run two agents in the same repository at the same time. For example, a Claude Code session in one terminal and Cursor in another, each tracked independently.
• Interrupted workflows: You can rebase or stash mid-session without losing Checkpoints.
• Line-level attribution: Every Checkpoint tracks which lines of code came from the agent versus which came from you.
• Subagent tracking: When an agent spawns a subagent, it receives its own nested Checkpoint. This preserves the full chain of command so you can see exactly how a high-level goal was decomposed into smaller agentic actions.
• Multi-agent support: Entire is agent-agnostic, supporting Claude Code, Cursor, Gemini CLI, GitHub Copilot CLI, Factory AI Droid, OpenCode, and external agent protocols.
• Separate checkpoint repository: You now have the choice to store Checkpoint data in a separate repository from your main code. This is useful when your codebase is public but your AI session data is not, or when teams want to centralize checkpoint data across multiple repos.

Where We're Headed

Now that we've turned raw developer activity into structured, reliable data, the Checkpoint becomes a new semantic unit, richer than commits, queryable, and shareable.

From here, we start to build toward team visibility, search, auditability, and a different way to think about code review.

Team Visibility

Git tells you who committed the code. Entire shows how it was built, recording token usage, agent type, and attribution directly in the repository so the invisible parts of development become a shared signal.

When a feature ships with 90% agent-generated code, that context will help the whole team. The author gets better feedback, reviewers know where to focus, and the next person to touch that code knows what they're walking into.

Search

Traditional git log answers "what changed," but in today's workflows a more pressing question is "why did we do it this way?"

We're making that answer searchable. Users will be able to surface the prompt that introduced a workaround or revisit the reasoning behind a library choice months later. The "why" will be part of your history.

Audit and Transparency

In regulated industries like finance, healthcare, and defense, "who wrote this code" has direct implications for compliance, liability, and safety. The Entire CLI will solve this by capturing accurate attribution and authorship at commit time. By mapping every step from human prompt to agent response to final human refinement, it makes clear what part the human played versus the agent.

Rethinking Code Review to Intent Review

Code review was built for a human pace. But with agents shipping entire features in a single session, reviewers are drowning in massive diffs and defaulting to approving with a measly "LGTM." The issue is already so prevalent that some open source maintainers are banning agent-authored contributions.

Checkpoints are the foundation, but the next step is a shift in methodology. We are moving beyond the diff to replace code reviews with intent reviews. This positions reviewers to start with intent by examining the prompt, the session transcript, and the reasoning behind key decisions. Instead of parsing 500 lines of syntax, they focus on the problem being solved and whether the right calls were made along the way.

At Entire, we're actively building the world's next developer platform in the open. If you're experimenting with agents, join the Discord, share what you're seeing, and help shape where this goes next.

• Read the docs
• Join the Discord
• Follow our progress on GitHub

With your help, we are building the Entire CLI as an independent semantic layer, allowing you to capture your context on every Git commit, no matter which agent you use.

This week we focused a lot of our attention on performance improvements and bug fixes, including major memory resource usage improvements when working with large repos, a new remote repository to store checkpoints separately from your working repo, and updates to many of the agents that are enabled in the Entire CLI.

Large Repo Memory Improvements

• We made significant memory improvements for users working in large repositories, with two related changes:
  • Metadata is now fetched sparsely with on-demand blob resolution, so only the data you actually need is fetched.
  • New content detection now uses transcript byte size instead of line count, which is more accurate and avoids unnecessary work.
• go-git/v6 has recently introduced a new LazyIndex which more efficiently handles idx and rev files, resulting in a lower memory footprint when interacting with large repositories. The Entire CLI has been upgraded to go-git/v6, to benefit from this and other improvements made since v5 was last released. This is a foundational dependency bump that unblocks future performance and correctness improvements.

Checkpoints in Remote Repos

• You can now store your entire/checkpoints/v1 branch in a separate dedicated repository, keeping your working repo's history clean while still giving you full checkpoint access across clones and teams.

Further Improvements

Agent Updates and Fixes

• External agent plugins are now auto-discovered during entire enable, entire rewind, and entire resume, with no manual config needed.
• Gemini CLI 0.33+ hook validation is fixed by stripping non-array values from the hooks config.
• Cursor 2026.03.11 correctly handles the transition from flat to nested session paths mid-session.
• Factory AI Droid now falls back to script parsing when the prompt isn't available through hooks.

Commit History Alongside Checkpoints

• Your Checkpoint history now shows all commits on a branch, including commits without Checkpoints. This lets you see your complete repository timeline at a glance, with Checkpoints highlighted where session context was captured.

entire trace Performance Insights

• We added a new diagnostic command to help report performance issues. If something feels slow during a session, entire trace gives you a clear breakdown to pinpoint what's causing it.

entire rewind Subdirectory Fix

• entire rewind now correctly resolves file paths when invoked from a subdirectory of the repo, rather than only working from the root.
  • Thank you to @mvanhorn for reporting and fixing this!

entire update Mise Detection

• entire update now correctly detects when the CLI was installed via mise, and suggests the right update command accordingly instead of giving a generic fallback.
  • Thank you to @mvanhorn for this fix as well!

That's all for now, rebels. As always keep the feedback coming our way, and if you have any questions, we're around on Discord. We hope you have a great rest of your week!

Boop.

We're a remote-first company, but every six months we bring our regional teams together for a Hack Week in-person to build, tinker, and collaborate face-to-face. This week, we gathered in Melbourne, Seattle, and Lisbon. Three cities. 25 Entirons. Many agents. Lots of ideas taking shape.

We also welcomed another agent to the alliance this week: the GitHub Copilot CLI, now equipped with checkpoints, resume, rewind, transcripts, and model tracking. Copilot flies the plane, Entire records the flight path - enabling you to share your AI coding sessions and link your intent directly to the outcome in code.

That'll do it for this week, rebels. As always, keep your contributions, PRs, stars and feedback coming. More ships and improvements coming your way next week.

Boop.

In a world with many agents, we believe your context — from chat sessions to logs and prompts — should automatically sync to the Git repository. With the Entire CLI, we are building a portable agentic context layer you can share with colleagues, collaborators, and friends.

With your help, this week we pushed a new Factory AI integration 🎉, created a new Repositories section on entire.io that lets you see all your org's repos, introduced a new external agent plugin system to help you bring your favorite agents to the Entire CLI, and lots of smaller improvements 👇

Agent Plugin System

• We're making it easier to integrate third party agents without forking the CLI. Agents can now run as standalone programs that follow a simple protocol, allowing them to be discovered on your system and used alongside built-in agents.

entire.io User Interface Updates

• See recently used repos in the sidebar and pin your most important ones for quick access.
• The checkpoints list now has more compact single-line rows for easier scanning grouped by day.
• A new breadcrumb header now lets you browse between commits within a Checkpoint.

Faster Hook Performance

We've heard your feedback. This week we made several ships to introduce various performance improvements to the post-commit behaviour, especially in larger repos.

• Replaced slow in-memory tree comparisons with native git operations, reducing hook latency on large repos.
• Added structured performance instrumentation. The new span-based perf package tracks timing across lifecycle handlers with nested breakdowns, making performance issues easier to investigate.
• To eliminate redundant calls in the prepare-commit-msg hook, staged file lists are now cached across sessions, and go-git's worktree.Status() (which scans all files) was replaced with native git diff --cached.
• Replaced O(N) go-git tree walks with git diff-tree in post-commit hook for faster commits.

Further Improvements

Updates to Cursor, Factory & OpenCode Agents

• Cursor now has full transcript analysis, enabling prompt extraction for shadow branch commit messages, summary extraction, and transcript position tracking.
  • Session metrics, including duration, turns, model name, and attribution, are now captured via hooks.
    • Thank you to @MarkoTatic for the detailed Cursor bug reports that helped drive these improvements!
• OpenCode sessions now end cleanly on quit via server.instance.disposed instead of lingering as active.
  • Thank you to @petrenk0n for reporting the empty sessions issue!
• An E2E test runner was added for Factory Droid sessions with full interactive flow coverage.
  • Thank you to @SvenMeyer for requesting Droid support!

Squash Merge Resume & Rewind

• entire resume parses all trailers, deduplicates sessions by ID, and sorts by timestamp to restore the correct state.
• entire resume on squash commits shows only the latest checkpoint instead of a confusing list of all sessions across the branch.
• entire rewind is fixed to pick the latest checkpoint in squash-merged commits, not just the first regex match.
• entire rewind is now able to handle squash commits properly.

Model Tracking in Checkpoints

• Checkpoints now capture which LLM model was used, persisted to metadata.json and visible in session info. The model is resolved from agent-specific hook payloads (Claude Code's SessionStart, Gemini CLI's BeforeModel).

Session & Hook Reliability

• Stale sessions are now properly cleaned up instead of lingering indefinitely.
• Fixed a bug where hooks could silently skip files that should have been tracked across turns.
• entire explain no longer hangs on repos with many checkpoints.
• Corrected inconsistent terminal behavior across different hook paths.
  • Thank you to @dismory for reporting the worktree config issue!

Setup & Developer Experience

• entire enable now supports --absolute-git-hook-path to set up git hooks with absolute paths to the entire binary, useful for environments where PATH resolution varies between shells or CI runners.
• Commit signing no longer breaks the test suite for contributors who have it enabled globally.
  • Thank you to @erezrokah for catching this and contributing the fix!

Thanks for all your help this week, rebels. Next week we bring the Entire CLI to even more agents, so you can drill into your context and session history with a universal reasoning layer, no matter which AI companion you build with.

Boop.

In a world where prompts are the new programming language, why not share them like code? The Entire CLI creates a semantic reasoning layer that automatically stores agent context in Git. Resulting in what we call, Checkpoints!

With help from the community, we shipped several improvements this week, including support for our first IDE. Today, we're bringing the Entire CLI to Cursor, enabling users to bind agent context to every push and explore, trace and share their intent. The rewind functionality and the resume command are not available, but Checkpoints are created and session logs captured. Thank you to @9bany for your early contributions to make this possible!

Here's what else changed:

OpenCode Support

• Since this week, the Entire CLI supports OpenCode.
• Fixed an issue with OpenCode and OpenAI Codex models not creating checkpoints when existing files were changed.
  • Thank you to @jaxondk for requesting OpenCode support, and to @ammarateya, @Avyukth, and @MementoMori123, whose OpenCode PRs helped validate the design!

Faster Checkpoints

• Introduced caching and optimized work tree updates to improve performance on Git commits and Git pushes.
• Squash-merged commits with multiple entire-checkpoint trailers correctly link to all their checkpoints on entire.io.
  • Thank you to @FSM1 for reporting the squash+delete workflow gap!
• To fix carry-forward false positives, orphaned shadow branches are no longer created when a user replaces agent content.
• Stale sessions no longer incorrectly condense into every commit.
  • Thanks to @BootstrapBits for the detailed concurrent session race analysis!
• Stuck checkpoint IDs and "no active sessions" errors are resolved.
  • HT @lakson-llc, @daeshawnballard, and @wmurphyrd!
• O(depth) tree surgery replaces O(N) flatten-and-rebuild for both metadata branch and shadow branch writes
• Extracted magic numbers to named constants for improved code quality.
  • Thanks to @ishaan812!

Further Improvements

• Web viewer
  • Added a searchable breadcrumb combobox making it easier to search and switch repos within the org.
  • In the spirit of the community, public repos are available on entire.io without logging in!
  • Fixed the tool calls section to be hidden for agents that don't report them.
  • False positive trail merge detection is fixed for new branches.
• Fresh clone support
  • entire enable now creates local metadata branch from remote when available, preserving checkpoints on fresh clones
• Linking commits to your checkpoints
  • The checkpoint linking question when doing git commit -m "commit message" now has an "Always" option.
• Depreciating "Auto-Commit"
  • To reduce complexity and with feedback from the community, we decided to cut the auto-commit command. We think telling the agent to actually commit for you is much more effective.
• Hook Scoping
  • Entire only creates .entire/logs/ folders in repos where Entire is enabled. Git hooks only run in repos where Entire is enabled.
    • Thanks to @knowsuchagency!
• Secret Redaction
  • Secret redaction is improved to not redact legitimate code.
• Unicode and Internationalization
  • UTF-8 truncation no longer produces garbled text for CJK/emoji characters.
    • Thanks to @wasabeef for identifying the root cause!
• Session Hygiene
  • Gitignored files (e.g. node_modules) are no longer tracked in session metadata.
  • Resume sessions are now sorted by creation time and stale session files are automatically cleaned up.
• Nix Package
  • Entire is available as a Nix package: nixpkgs/entire.
    • Thanks to @evanlhatch for requesting this and @DieracDelta for the interim fork!

Keep the contributions coming. Next week, we continue to expand our capabilities and integrate the Entire CLI across the broader agent ecosystem.

That's all for now, rebels.

Boop.

Last week, we introduced Checkpoints to the world — our first primitive designed to tackle one of the biggest problems in agent-driven development: context. Today, conversations, reasoning, and file changes are fragmented or lost between sessions. As agents generate hundreds or even thousands of lines per interaction, that context loss compounds quickly. Agents retrace steps, duplicate reasoning, waste tokens, and lose the thread of decisions made hours or days earlier.

To bridge this gap, the Entire CLI automatically captures agent sessions, creating a semantic reasoning layer that binds agent context to Git on every push. Resulting in what we call Checkpoints. This week we focused on making the Entire CLI easier to integrate with other agents, including a refactor that simplifies how external tools plug into the workflow and interact with grouped changes. Stay tuned, new agent support shipping very soon.

And with your help, we shipped a variety bug fixes, performance improvements, and key updates:

Expanding Agent Integrations and Capabilities

• The Entire CLI codebase has a stronger multi-agent framework, enabling faster integration of new agents.
• The Entire CLI integration with the Gemini CLI supports full transcript parsing, Checkpointing, and session explanations.

Secret Detection

• Checkpoints runs layered secret scanning using gitleaks patterns combined with entropy analysis.
• Secrets are redacted across all persistence paths — including shadow branches, metadata, and condensed logs — ensuring sensitive data does not leak into Git history.
  • Thank you to Hi120ki, andreidavid, and Pythoninthegrass!

Smarter Hook Management

• Hook installation is more resilient, with automatic resolution of hook directories supporting worktrees and custom configurations using git --git-path hooks.
• Existing Git hooks that the Entire CLI does not recognize are preserved.
• External hook managers such as Husky or Lefthook are detected during entire enable, with a warning before anything is overwritten.
  • Shout out to AlienKevin, Camwest, SchutteJan, and FSM1!

Checkpoint Reliability

• Subagent task file modifications are correctly captured in Checkpoints.
• Deleted files in task Checkpoints are properly tracked.
• Each Checkpoint produces exactly one commit, eliminating noise in Checkpoint history.
• Git-ignored files such as node_modules are no longer tracked in session metadata.
  • Danke, BootstrapBits!

Improved entire enable

• The setup experience has been redesigned with clearer prompts and better defaults, making it faster and more intuitive to get started in a new repo.
  • Big thank you to Jayanth-iyer, TyceHerrman, and Marcodicro-dp!

Session Restore Fixes

• Sessions that previously failed to restore after repo changes (stash, pull, rebase) recover correctly.
• Full Checkpoint history is preserved across branch operations.
  • HT, Jaydenfyi!

Empty Repo Support

• Improved messaging when the Entire CLI is used in a freshly initialized repository that has no commits yet.

In the coming week, we’ll focus on integrating the Entire CLI across the broader agent ecosystem — so every developer can have pluggable, independent context natively tied to their Git repository, no matter which agent they use.

Boop.

This week we launched Checkpoints, our new primitive that automatically captures agent context as first-class, versioned data in Git. It's our first crack out the gate at building a universal semantic reasoning layer for every agent. Thanks for the love, feedback, the stars, and PRs. With your help, we've shipped new features, improvements, and bug fixes to the Entire CLI and web UI. Here's a few of our favorites:

• We've improved Google Gemini CLI support — explain, rewind, and resume now work with Gemini sessions.
• Layered secret detection using gitleaks now patterns on top of entropy-based redaction, strengthening protection against accidental credential leaks and reducing risk in every commit.
• Git hooks can now chain with existing hooks. Break less, keep working the way you expect.
• On entire.io, we made the Checkpoint view easier to navigate by bringing session logs and code diffs into a single, unified view.

And of course, that's just a few transmissions. For various more bug fixes & improvements — see more changes to the Entire CLI here.

This is it for this round. New dispatch every week. Boop.

*TLDR: Today, we are announcing our new company, Entire, backed by a $60 million seed round to build the world's next developer platform. We are also shipping our first product as open source CLI to tie agent context into Git on every push.*

The game has changed. The system is cracking.

In the last few months alone, the fundamental role of a developer has been refactored. From Anthropic's Claude Code with Opus 4.6, to OpenAI's latest GPT-5.3-Codex agentic coding model, to Cursor's Composer 1.5 and more, advancements in agentic intelligence have turned the flow of coding on its head. The terminal is becoming the new center of gravity, as developers prompt fleets of agents across multiple terminal windows at once. Spec-driven development is becoming the primary driver of code generation. Agents now interoperate in parallel, generating and evaluating hundreds of variants simultaneously. As a result, massive volumes of code are being generated faster than any human can reasonably understand.

Yet today, we still rely on a software development lifecycle built before the era of the cloud, inherently designed for human-to-human collaboration. And the cracks are forming. Issues were designed for human planning and tracking, not as structured, machine-readable units of work. Git repositories were never extended to version everything developers build with in the AI era. Pull requests simply do not scale for large monorepos. Every day, agents are being choked and throttled by centralized API capacity and rate limits. The truth is: the entire software ecosystem is being bottlenecked by a manual system of production that was never designed for the era of AI in the first place. A system that cannot be retrofitted for what's ahead.

Just like when automotive companies replaced the traditional craft-based production system with the moving assembly line, we must now reimagine the entire software development lifecycle for a world where machines are the primary producers of code. Creating the assembly line for the era of agents.

Announcing Entire: The world's next developer platform

This is the purpose of our new company Entire, to build the world's next developer platform where agents and humans can collaborate, learn, and ship together. A platform that will be open, scalable, and independent for every developer, no matter which agent or model you use.

Entire will be based on three key components: a git-compatible database that unifies code, intent, constraints, and reasoning in a single version-controlled system; a universal semantic reasoning layer that enables multi-agent coordination through the context graph; and an AI-native software development lifecycle to reinvent agent-to-human collaboration.

In pursuit of this vision, we are proud to be backed by a $60 million seed investment led by Felicis, with support from Madrona, M12, Basis Set, 20VC, Cherry Ventures, Picus Capital, and Global Founders Capital. Entire is further backed by a slate of international investors including Gergely Orosz, Theo Browne, Jerry Yang, Olivier Pomel, Garry Tan, and others—who all understand that software development is ready for its next platform shift.

Our first release: The Entire CLI to track agent context

Today, agent sessions are ephemeral. Prompts live in terminals and reasoning lives in context windows. The decisions, constraints, and iteration that produce code disappears the moment you close the session. Git preserves what changed, but nothing about why. With agents generating hundreds or thousands of lines per session, this context loss compounds fast. Without shared context, agents can't collaborate effectively. They retrace steps, duplicate reasoning, waste tokens, and lose the thread of decisions made hours or days earlier.

Our first ship makes that missing context durable:

Checkpoints are a new primitive that automatically captures agent context as first-class, versioned data in Git. When you commit code generated by an agent, Checkpoints capture the full session alongside the commit: the transcript, prompts, files touched, token usage, tool calls and more. This context becomes the foundational write-path of our semantic reasoning layer. You can browse checkpoints by branch, drill into individual sessions, and trace how your codebase evolved through human-and-agent collaboration commit by commit.

Our plan is to support Checkpoints for every agent. Today, Entire CLI ships with support for Anthropic's Claude Code and Google Gemini CLI. Codex, Cursor CLI, and other agents coming soon.

How it works

Checkpoints run as a Git-aware CLI. On every commit generated by an agent, it writes a structured checkpoint object and associates it with the commit SHA. The code stays exactly the same, we just add context as first-class metadata. When you push your commit, Checkpoints also pushes this metadata to a separate branch (entire/checkpoints/v1), giving you a complete, append-only audit log inside your repository. As a result, every change can now be traced back not only to a diff, but to the reasoning that produced it.

Checkpoints are useful immediately:

• Traceability - inspect the reasoning behind any agent-generated change
• Faster Reviews - review intent and constraints, not just diffs
• Better handoffs - resume work without replaying prompts or sessions
• Less token waste - agents stop repeating mistakes that you corrected in past sessions
• Multi-session and agent support - support for concurrent agentic sessions

Getting Started

The best part is that you can set up Entire in two easy steps.

Then navigate to your repository and run entire enable — follow the prompts to configure Entire for that project. That's it. Your agent sessions are captured automatically - in a structured and ready-to-use format.

No more stealth. We are building in the open!

Checkpoints are our first step towards building a universal semantic reasoning layer for agents. Today, it gives you traceability and history. Tomorrow, it will become the shared memory that allows agents to coordinate, hand off context and build together without collision or loss of understanding.

Most importantly, we're releasing the Entire CLI open source project because we believe that this layer should be portable, independent, and available for every single agent or model. And because we know, we are better with the contributions of the interconnected community of open-source developers.

Our roadmap will be directly paved by your feedback, in Discord and in GitHub Discussions. We're ready for it. See you there.