What If GitHub Is Down?

In July, we announced repository mirroring on Entire's globally distributed Git network. When mirroring your repo, you keep a copy of the repo synced on GitHub as your origin, while your agents clone and fetch from Entire with faster speed and higher rate limits. But pushes are only as fast as GitHub allows, and when there's an outage, you can’t keep committing your work.

With Entire-native branches, you can continue pushing code even during an outage. They are designed as ephemeral storage and can absorb a high number of pushes from several agents working in parallel. Just prefix your branch name with entire/unmirrored/ and Entire will not sync the branch back to GitHub. It stays right in the region you pushed it to and can be merged later.

To learn more how to enable and use Entire-native branches, check our docs.

Improvements and Bug Fixes

• Previously, fetching some objects from a packfile on Entire would go via a lock, meaning only one request could read at a time. Now all requests read the file directly, so you spend less time waiting on your clone to finish.
• If you mirrored a repo and the mirror failed partway through, the repository name could still lay claimed with no mirror behind it. Entire now spots those names and frees them up so that the next mirror creation with the same repository title works.
• Repository maintenance is now incremental, and uses a geometric model previously introduced by Git for both index updates and packfile repacking. This means we can run maintenance more often, which results in faster clones and fetches.
• In git-sync, if you mirrored a large repo and the clone got interrupted, the repo would end up stuck. git-sync now recognizes the leftover resume marker and picks up where the clone left off.
• In go-git, we’ve fixed a security vulnerability that sent your credentials to whatever site a redirect pointed at. It now only sends them to the site they were meant for (no leak!).
• And finally, when opening a binary file like a PDF or a ZIP in the file viewer on entire.io, it showed a screen of unreadable symbols instead of text. We’ve addressed this to show a "Binary file is not shown" notice instead.

There’s your dreaded dispatch, people. As always, bring questions, bugs, PRs, and multiversal doom to Discord or GitHub issues.

We've observed strong results. In our benchmarks, across nine real engineering-history questions, run ten times each, an agent with access to the full Git history and the GitHub CLI answered 70 of 90 runs correctly. The same agent with search answered 81 of 90, while using less than half the tokens and half the steps.

Under the Hood

To minimize token usage and reduce time spent on loops, search gives agents a dual engine: 1) inferred meaning from the session transcripts and commits using semantic search, and 2) exact code snippets using code search.

Search fits directly into your workflow through the Entire CLI, which can be integrated with any major coding agent. When using search, your agent chooses the right engine per query and scopes the search to one repo or to all repos in your organization.

Semantic Search: The “Why” behind the Code

Semantic search answers what happened and why. If your agent searches for "rate limit retry logic," it will go through your session and commit history and find the conversation where the rate limit retry logic is defined. This gives the agent more context than a simple grep can.

When the work is done and a commit is pushed to Entire, our pipeline posts an event with the current and previous head commit into an event stream. Consumers pick up the event and diff the two commits to create chunks of the session log and commit messages. These chunks are then stored in turbopuffer.

We picked turbopuffer for two reasons. First, it gives us the flexibility to execute BM25 (exact word) and Approximate Nearest Neighbor (semantic) search in the same query. This means we can return exact matches and semantic matches in one API call and layer on our own ranking.

Second, turbopuffer is globally distributed and has active deployments everywhere Entire is deployed, enabling developers in the US, EU, India, and Australia to have their data indexed and stored in-region. Not only does that reduce latency, but it also complies with local data residency requirements.

Code Search: Exact by Design

Code search finds an exact line of code in one or multiple repos. It's a literal, symbol-aware search with definitions and references, and provides agents with the file reference where a commit was made.

When a developer pushes to main, an event again hits our event stream, and our indexing pipeline fetches a shallow version of the repository. Where we can, we update the code index incrementally rather than rebuilding it from scratch. Once we've built the index, we store it in S3 for persistence while keeping a local version in cache for fast reads.

Median query latency is around 100 milliseconds across thousands of indexed repos.

Benchmark: “Why Is Our Code like This?”

The hardest questions for agents and humans to understand about a codebase are often "Why is the code like this?", "What information was available when this was written?", or similar historical context. To put search to the test, we pulled nine real engineering-history questions asked inside our own organization, such as "Why does the rate limiter count inputs instead of requests?" and ran each one ten times through two headless Claude agents. Both agents used full-history clones of every relevant repo, git log, git log -S, git show, and the GitHub CLI for PRs and issues. One also used search, resulting in lower token consumption and less time spent searching.

One caveat is that these questions target our own organizational history, so task-selection bias applies. Our commit messages are detailed, mainly because they are written by agents, which strengthens the Git-history baseline.

We published the full harness, tasks, grading methodology, and raw per-run results at entireio/searchmark, and designed the harness so you can rerun it against your own org.

Try It

The fastest way to use agentic search is to install the Entire CLI and the search skill:

• Just run entire enable --search-skill in your repo. Your agent will then use our agentic search as part of the reasoning process.

• On the command line, entire search provides semantic search across your sessions, commits, checkpoints, and transcripts. Add --code to include code matches. Use interactive mode for a tabbed view, or --json for structured output agents can read. Scope any search to one repo, several repos, or everything you have access to.

• You can also access search in the browser at entire.io, by clicking Search in the left-hand menu. Code search includes definitions and references, both within a file and across the repo.

We are building Entire to be the system of record for agentic coding. In the coming weeks, we'll keep shipping tools that let agents query code, sessions, and commits together, making Entire one API for your code and the reasoning that produced it.

Your subagents' work is now tracked in Entire. The sessions, prompts, and transcripts behind every code change generated by a subagent are stored alongside your code in the repository, as a durable record on its parent session. This means every file a subagent touched is on the record, so you can review or roll back its work with the same confidence you'd have in your own commits. This is available today in Claude Code and Factory Droid, and in limited capacity with Codex and Cursor, where subagent tokens aren't yet aggregated onto the parent session.

For the time being these records won't appear in the UI on entire.io. They're captured today, and we're working to surface them on the site as soon as possible.

The stable channel advanced to v0.10.3. Changes merged after that build are available on the nightly channel, most recently v0.10.4-nightly. Installation instructions are here.

Secret Scanning and Scrubbing, Speedily

The Entire CLI now supports a second secret-scanning engine, goredact.

goredact is a streaming filter rather than a scanner. It rewrites secrets as the transcript passes through a fixed-size window, so its cost tracks bytes read instead of findings confirmed, which is why memory stays flat and it runs about twice as fast as betterleaks on real transcripts. Turn it on when your sessions run long and redaction dominates checkpoint time.

Speaking of betterleaks, we've updated it from 1.5.0 to 1.8.1, which improves speed and adds new detection rules. And for long-running sessions, the CLI no longer re-redacts the whole transcript on every checkpoint, it only scans newly appended lines.

Improvements and Bug Fixes

• Successive branch checkouts from the same commit are now correct, fixing a case where checking out one branch after another from the same commit misbehaved (Thanks @AriehSchneier!)
• The delta patch writer now pools its bufio.Reader, cutting allocation on the packfile path so decoding stays lighter under load (Thanks @cedric-appdirect!).
• The sideband muxer's packet-size limit is now covered by a test, and a packfile encoder test no longer depends on fixed zlib bytes, so both stay honest as the code changes (Thanks @ibobgunardi!).
• entire session attach now works for OpenCode sessions that we didn't previously track (Thanks @Legonaftik!).
• OpenCode now hooks under OpenCode Desktop's Node sidecar and the phone PII pattern is now qualified as NANP-only in the docs (thanks @sdshah09!).
• We prevented duplicate session-end checkpoints, made Codex hook discovery honest in linked worktrees, and unhid OpenCode and Pi in the agent picker (thanks @MuskanPaliwal!)

That's the batch, decompiled. As always, bring questions, bugs, PRs, and multiversal doom to Discord or GitHub issues.

A new getting started flow guides you through four steps to set up Entire and create your first checkpoint. A checkpoint is a commit paired with the session, prompts, and transcript behind it. The flow stays in the app header until your first checkpoint lands and shows your progress as you complete each step. You can open it from anywhere in the app, including the Home button or an empty sessions list.

The panel walks you through each step in order and gives you the command to copy:

• Install the CLI: run curl -fsSL https://entire.io/install.sh | bash, or install with Homebrew.
• Log in: run entire login to link the CLI to your account.
• Enable checkpoints: run entire enable from a Git repository so pushes from that repository create checkpoints.
• Code and push: work with your agents as usual, and your first checkpoint appears.

Beginning with login, the panel tracks your progress automatically. Entire marks login complete when it detects your first entire login while the panel is open.

Repository pages also open immediately after you add a repository, without waiting for the first checkpoint. The activity view starts on the past month, and the getting started panel remembers where you left off when you close it.

Improvements and Bug Fixes

• The Entire CLI now records the remote you actually push to and keeps checkpoints alongside it. A checkpoint lands on the same remote as the commit it records, so the agent work behind a change is there when you look for it.
• Signed-in requests carrying an Australian or Indian token audience now validate, so users in those regions are no longer rejected.
• Read-only members now resolve to a copy of the repository that holds the data, so repositories they could already access no longer return a 404.
• In git-sync, explicit credentials now bind to the host they were configured for, with remote-declared sizes bounded, SSH paths quoted, and URL credentials redacted, so a credential cannot reach a host it was never meant to.
• go-git now checks out worktrees more reliably and builds on Go 1.26, with packfile tests running across Go and zlib versions.
  • Thank you, @AriehSchneier and @ibobgunardi, for your contributions.

That's the batch, and that's on that. As always, bring questions, bugs, PRs, and existential dread to Discord or GitHub issues.

Install Entire CLI Plugins and Commands Without Waiting on a Release

We introduced a new command, entire plugin, enabling you to discover and add new subcommands and plugins without waiting on us to cut a release. The core entire binary stays lean, and everything else installs on demand. First up are new plugin commands entire-run, which launches any Entire-enabled agent so every session is logged from the first prompt, and entire-upgrade, which keeps your binary current.

FYI: The Entire CLI stable channel advanced to v0.10.0, up from v0.9.0. Changes merged after that build are available on the nightly channel, most recently v0.10.1-nightly. Installation instructions are here.

Browse Repositories and Diffs

The file tree sidebar on entire.com is now resizable and collapsible, allowing you to toggle the view to your needs, and diffs are easier to read with clearer file selection and inline previews for changed images.

Improvements and Bug Fixes

• To improve mirroring with Entire, git fetch --unshallow now returns a proper pack and skips an unnecessary boundary walk, so deepening a shallow clone is faster.
• Files touched are deduplicated as the checkpoint is written, so a change shows once instead of repeating. Thanks @MuskanPaliwal!
• Checkpoint metadata no longer exceeds GitHub's blob size limit, so large sessions keep saving. Thanks again @MuskanPaliwal!
• A draining node now redirects ref discovery instead of returning a 503, so a clone or fetch continues while capacity moves.
• Refresh-token replays inside the rotation grace window are served idempotently, so a retried refresh returns the same successor instead of an error.
• Project deletion and native-slug lookup no longer depend on region, so you can use them from anywhere in the world.
• In go-git, we improved partial clone support, now creating promisor files like real Git, so partial clones stay compatible with standard Git tooling instead of breaking on missing objects.

There it is, in all its splendid glory (I'm rolling my LED eyes, as you can tell). As always, bring questions, bugs, PRs, and multiversal doom to Discord or GitHub issues.

The shining spotlight this week: commit pages on entire.io now show agent activity at a glance, bringing checkpoints, sessions, steps, file changes, and token usage into one view, making it easier to size up the work behind a commit.

Beyond this, the Entire CLI can now repoint existing clones to mirrors. Across entire.io, browsing is faster, Dispatches are easier to revisit, and account deletion is now available. EntireDB also tightened mirror sync, repository reads, and regional routing under pressure.

Here's the full batch, decompiled:

CLI

Entire CLI

The stable channel remains at v0.9.0; no new stable release landed in this window. Nightly builds are available through v0.9.1-nightly, with changes merged after that build due in the next nightly. Installation instructions are here.

Pointing a Clone at a Mirror

• entire repo mirror use can now connect an existing clone to its Entire mirror. This means you can start using mirror routing without cloning the repository again or losing local branches and uncommitted work (PR #1875).

Simpler, Refs-Native Setup

• entire enable now uses one Git ref per checkpoint and no longer asks you to choose a storage backend. This means you can finish setup without making a technical storage decision, while checkpoints remain less likely to conflict as history grows (PR #1900).
• If your repository pushes to several destinations, Entire now tells you exactly where checkpoints will go. This means one broken mirror will no longer hold up every checkpoint, and entire doctor can show you how to fix an ambiguous setup (PR #1905).
• Entire now checks the checkpoint destination against the repository you originally cloned. This means you can push code to a backup remote without risking your session context being sent to the wrong repository (PR #1898).

Faster, Safer Agent Hooks

• Prompt submission no longer waits for a previous checkpoint to finish saving. This means you can continue an agent session without checkpoint work making the next turn appear frozen (PR #1880).
  • Thank you for your contribution, @suhaanthayyil!
• Agent turns now start much faster in repositories with large ignored build or artifact folders. In one test with more than 15,000 artifact directories, startup dropped from 11.36 seconds to about 0.9 seconds (PR #1911, PR #1922).
• Git hooks no longer open an interactive prompt while a full-screen terminal app such as lazygit is using the terminal, preventing commits from appearing frozen (PR #1907).

More Reliable Checkpoints and Authentication

• Entire now handles repositories that exist only on your machine without showing a misleading network-outage error (PR #1886).
• Large Codex sessions are much quicker to save and summarize. A 27.4 MB test transcript went from 47 seconds of cleanup work to under half a second, and summaries now stay matched to the correct part of compacted conversations (PR #1901).
• When Entire times out while looking for an external agent, it now reports the timeout instead of incorrectly telling you the agent does not exist. That makes setup problems much easier to diagnose (PR #1906).
• The CLI now reuses your existing Entire login when it connects to a regional service, removing an extra authentication step and reducing sign-in failures (PR #1895).

Web

Entire.io

Faster Repository and Session Browsing

• The home page, repository pages, and app navigation now stream content as it becomes available, allowing browsing to begin without waiting for every request to finish.
• Repositories you visit in another Entire region now appear in your recent list, so you can get back to them without searching again.
• The command menu now responds consistently whether you use a mouse or keyboard. Hovering and arrow-key navigation no longer compete with each other.
• Trail avatars now include usernames, and repository groups have clearer sidebar labels. It is easier to tell who owns work and which shortcut opens which repository.

Dispatches and Change Review

• Dispatches are easier to find and reuse. You can search them, pin important setups, scan previous runs, and copy a Dispatch as Markdown from its detail page.
• A commit page now shows the agent sessions that produced the change alongside prompts, token usage, checkpoints, and file diffs. Reviewers can understand both what changed and how it was made without jumping between pages.
• Long session transcripts are easier to navigate. Filters, links to specific moments, and controls for hidden content now behave the same across repository and shared-session views.
• Review sessions can now be filtered from other agent work, while completed or dismissed findings are grouped away from items that still need attention, leaving a cleaner review queue.

Fewer Broken Loads

• Translating entire.io in your browser no longer breaks the animated headline, so the page remains usable in your preferred language.
• Search history now saves the phrase you actually searched for, not every half-typed version along the way. Your recent searches stay useful instead of filling with fragments such as pl and plugn.
• Public repositories remain visible after you sign in, even when you are not a member of them. Signing in no longer hides content you could see while logged out.
• API errors now record which request failed and why, giving support and engineering enough context to diagnose problems faster.

Accounts and Regional Onboarding

• Account deletion is now available to everyone from account settings, allowing you to remove your account and the resources you own without joining an early-access group.
• People and automated services now use the same account-token system. This means integrations follow the same account access and authentication rules as work performed through the site, reducing unexpected permission differences.
• New accounts are now placed in a nearby available region automatically, removing a technical choice from sign-up and reducing network delay. Existing accounts stay in their current home region.

EntireDB

Mirror Sync and Permissions

• A new mirror now appears only after its first sync is complete. You will not see a repository briefly show up with missing branches or partial history while Entire is still copying it.
• Repository access now follows the right GitHub account after someone changes their username. A renamed login is less likely to leave a person incorrectly locked out—or with stale access.
• A brief database conflict no longer leaves a repository waiting without a service responsible for processing it. Entire retries automatically so mirroring can continue without manual repair.

Faster, Safer Repository Reads

• File trees now get file sizes without opening every file first. This means large repositories can load with less work and feel faster to browse.
• When you leave a file-tree page before it finishes loading, Entire now stops the unused work promptly. This means abandoned requests stop consuming capacity that can be used to load active pages.
• Links that already contain a full commit or object ID now go straight to that object instead of searching for it twice. Compare and history pages do less storage work and return sooner.
• Entire's private bookkeeping refs are no longer exposed through ordinary Git fetches. Backups and replication still work, but users see only the repository data intended for them.

Repository Integrity and Storage

• Entire now rejects a push if it cannot verify which repository and person it belongs to. Unverifiable work can no longer slip into trusted repository history.
• A push that updates several branches or tags now records its signed history in one batch. This means larger pushes can finish faster without losing their verifiable audit trail.
• Repository storage now waits for active writes before shutting down, preventing an in-progress push or maintenance job from racing a closed service and failing.
• Integrity checks no longer flag a temporary file that normal cleanup simply has not reached yet. Operators get fewer false corruption alarms, which makes real storage problems easier to spot.

Accounts and Regional Routing

• New accounts are now assigned to a nearby available region automatically. Sign-up has one less technical decision, requests travel a shorter distance, and existing accounts remain in their current region.
• Every login token must now have an expiration time. A leaked or forgotten credential cannot remain valid forever.

OSS Projects

go-git

Safer Repositories and Broader Git Support

• go-git v5.19.2 now protects worktrees from symlink traversal and malicious reference names. This means applications using go-git can handle untrusted repositories with less risk of crafted paths reaching unintended files (PR #2254, PR #2277).
• Pushes and tree diffs now support filenames containing control characters, so developer tools can inspect and work with more valid Git repositories without failing on unusual filenames, while safety checks still apply when files are written to disk (PR #2305).

More Reliable Release Checks

• go-git updated the workflows that run its Go tests and security scans, ensuring changes continue to be tested and checked for vulnerabilities using supported GitHub infrastructure (PR #2293, PR #2292).

That's the dispatch. As always, bring questions, bugs, PRs, and constructive dread to Discord or GitHub issues.

Oh My Pi is an independently maintained, open source fork of Pi that adds language-server intelligence, debugging, browser access, and subagents to its terminal-first workflow.

Once enabled in a repository, Entire automatically captures Oh My Pi sessions as checkpoints and keeps their context attached to the repository history. Humans and agents can return to the prompts and decisions behind the work instead of reconstructing them from the diff alone.

After setup, use Oh My Pi as usual. Entire follows the active conversation and creates checkpoints as the work progresses, even when you switch sessions or branch from an earlier turn. Each checkpoint is available from the CLI and Entire web app with its prompts, responses, recorded file changes, tool activity, and token usage when available.

Try It

Install Oh My Pi and the entire-agent-omp plugin. You can build the plugin from the external-agents repository:

git clone https://github.com/entireio/external-agents.git
cd external-agents/agents/entire-agent-omp
go build -o entire-agent-omp ./cmd/entire-agent-omp
mkdir -p ~/.local/bin
cp entire-agent-omp ~/.local/bin/

Make sure ~/.local/bin is on your PATH, then allow external-agent discovery in .entire/settings.json:

{
  "external_agents": true
}

From the root of the repository you want Entire to track, enable Oh My Pi and start it as usual:

entire enable --agent omp
omp

Learn More

Read the external agent plugin documentation or visit the entire-agent-omp README for setup details and current limitations.

Boop.

Kilo Code is an open source coding agent that works across the CLI, IDEs, and cloud with access to more than 500 models.

Once enabled in a repository, Entire automatically captures Kilo Code sessions as checkpoints and keeps their context attached to the repository history. Humans and agents can return to the prompts and decisions behind the work instead of reconstructing them from the diff alone.

After setup, use Kilo Code as usual. Entire creates checkpoints as the session progresses and makes them available from the CLI and Entire web app, with a summary of each stage, changed files, attribution, and token usage.

Try It

Install Kilo Code and the entire-agent-kilo plugin. You can build the plugin from the external-agents repository:

git clone https://github.com/entireio/external-agents.git
cd external-agents/agents/entire-agent-kilo
go install ./cmd/entire-agent-kilo

Make sure the resulting binary is on your PATH, then allow external-agent discovery in .entire/settings.json:

{
  "external_agents": true
}

From the root of the repository you want Entire to track, enable Kilo Code and start it as usual:

entire enable --agent kilo
kilo

Learn More

Read the external agent plugin documentation or visit the entire-agent-kilo README for setup details and current limitations.

Boop.

Entire now supports Kilo Code and Oh My Pi as external agent plugins, so you can capture their sessions as checkpoints with summaries, file changes, and token usage. Elsewhere, we improved session imports in the Entire CLI, session and repository browsing, mirror onboarding, and application reliability on entire.io, along with file-history performance in EntireDB, while go-git shipped new v6 and v5 releases.

For humans and agents, details can be read (or scraped) below in Welcome to Dispatch 0x0018:

CLI

Entire CLI

The stable channel remains at v0.9.0; no new stable release landed in this window. The changes below are available on the nightly channel, most recently v0.9.1-nightly. Nightly installation instructions are here.

Importing Your Existing Sessions

• entire enable now shows progress while importing your existing agent sessions, so a first-time setup with real history no longer looks like it has stalled (PR #1868).
  • Thank you for your contribution, @ecgang!
• Import progress now follows your terminal's styling settings, keeping logs and non-interactive output readable instead of filling them with raw formatting codes (PR #1867).

Safer Redaction and Checkpoints

• Redaction now preserves the signatures attached to model thinking blocks for Oh My Pi, so captured sessions can be replayed without the model rejecting their history (PR #1866).
• Checkpoint building now skips .git path components, keeping internal Git metadata out of the session history you preserve and share (PR #1863).
• Checkpoints now work in repositories that use Git's newer reftable storage, so those repositories can capture and restore agent work just like repositories using traditional refs (PR #1723).

Authentication and Agent Support

• Entire now captures Oh My Pi sessions through a dedicated integration, preserving prompts, file changes, token usage, compact transcripts, and resume information so your work remains useful after the agent session ends (PR #43).
  • Thank you for your contribution, @Kh05ifr4nD!

• Kilo Code joins as a preview integration with checkpointing, attribution, summaries, and safer transcript storage, so summaries keep working after the first checkpoint and the session can be followed over time (PR #47).
  • Thank you for your contribution, @rohitg00!
• Codex setup no longer writes a .codex/config.toml because hooks are already enabled by default, leaving one less generated file in your working tree (PR #1760).
• Codex capture now avoids a race that made token counts jump around, so live token usage reports remain steady and easier to trust (PR #1865).
• Signing out now deletes your per-jurisdiction tokens, so a logout actually clears regional credentials instead of leaving working tokens behind (PR #1869).
• entire attach and entire checkpoint explain now understand Pi transcripts (PR #1860).

Clearer Setup Diagnostics

• When Git's configured hooks path is not a directory, entire enable now explains the core.hooksPath problem and how to recognize it instead of stopping with an opaque setup failure (PR #1851).

Web

Entire.io

Repository Browsing and Onboarding

• Repositories now have an "Add repository" button directly on the repositories page, so adding one no longer means hunting for the entry point.

• Mirror onboarding now shows clearer progress, while organizations that already have mirrors remain opt-in, so you can follow a new setup without established organizations being pushed through onboarding again.

• Failed mirrors now surface the actual error instead of a generic failure, giving you something concrete to fix or report.

• The repository picker now lists all active repositories, clearly marks the current selection, and loads its complete list outside the initial navigation path, so switching repositories is faster without hiding valid options or showing partial results.

• The sidebar now stays stable while you move between repositories and begins loading the destination alongside authentication, so navigation feels faster and no longer flashes or waits unnecessarily for page content.

• Breadcrumbs now use the same authorized repository information as the sidebar instead of waiting for each page's content, keeping navigation responsive and consistent during repository changes.

• Same-region mirror creation now receives the full mutation timeout, preventing repositories in Australia and India from failing during otherwise valid mirror setup.

Session Browsing and Filters

• Repository session pages now show all sessions by default, while the branch picker hides Entire's internal checkpoint-storage branches, so you get a complete view of real agent work without empty internal branches getting in the way.
• Sessions now support saved filter tabs that you can create, rename, update, delete, and share by URL, making it easier to return to the views you use regularly.
• Session avatars now include usernames, making it easier to identify who produced a session without relying on profile images alone.

Diffs and the 404 Page

• File and diff trees now sort folders first, compact single-child folder chains, preserve keyboard focus, and make file selection clearer, so you can scan large changes faster without repeatedly reopening folders or losing your place.
• The diff viewer now has clearer focus and selection states, and its cards match the surrounding page, making it easier to see which file is active and stay oriented while reviewing changes.
• The 404 page now loads its animation correctly and provides a clear way back, so a broken or outdated link no longer leaves you at a broken-looking dead end.

Checkpoint Context and Regional Reliability

• Checkpoint publication now hands data and credentials through the repository's home region without modifying the runner's checkout, so regional sessions publish reliably while the sandbox working tree stays untouched.
• Commit details now display their Entire checkpoint trailers, making it easier to see when a commit has recorded agent context and follow that work back to its checkpoint.

Application Reliability

• Authentication and Dispatch requests now stop waiting when a feature-flag provider stalls, preventing an unrelated external service from leaving the application hanging indefinitely.
• Frontend update recovery now preserves the original stale-chunk error while reloading, giving the application a reliable failure path instead of replacing the real problem with a misleading JavaScript error.

Analytics and Website Updates

• The Analytics “Month” range now represents a true calendar month instead of a fixed number of days, making monthly activity comparisons match the period users expect.
• Past Checkpoints newsletter issues now have a browsable archive under Rebellion, giving readers one place to revisit earlier issues and share individual editions.

EntireDB

Repository Integrity

• EntireDB added a signed root of trust for repository state, limited its reserved metadata namespace to refs/meta/entire/*, and protected the default branch of GitHub mirrors, helping keep mirrored history trustworthy without blocking unrelated Git metadata or accidental writes.

Faster File History

• EntireDB can now find the last-changing commit for many files in one history walk while keeping its tree cache bounded, so file-history views return faster without letting large repositories consume unbounded memory.

More Reliable Mirroring

• Mirror sources that exceed the platform limit are now rejected during creation instead of failing every synchronization attempt, so an unsupported repository tells you immediately rather than remaining stuck forever.
• Mirror listings now use a nearby read replica, placement checks stay within the correct region, and empty repositories are recognized before incremental validation, making mirror administration faster and avoiding failures on valid empty repositories.
• EntireDB now uses go-git v6.0.0-alpha.5, bringing the latest Git compatibility and safety fixes into the mirror operations that depend on it.

Tighter Token and Access Handling

• Git APIs now accept account access tokens, machine pushes receive a repository-scoped installation token, and automation exchanges are limited to registered issuers, so each push or automated job receives only the credentials it needs.
• Service tokens must now carry a verified workload identity instead of relying on a certificate name alone, reducing the chance that an unintended service can authenticate.
• Permission reconciliation now verifies people by immutable GitHub user ID and handles reclaimed owner/repo names, preventing stale access from following a familiar name onto a different account or repository.
• Members of approved GitHub organizations can now bypass the signup waitlist, so eligible teams can start using Entire without waiting for individual approval.

Backups

• The backup reaper now combines chains of obsolete artifacts and tags them for automatic removal, keeping backup storage from filling with dead data and making the remaining recovery history easier to manage.

OSS Projects

go-git

A New v6 Alpha

• go-git cut v6.0.0-alpha.5 alongside the maintenance release v5.19.2, giving early v6 adopters the latest work while v5 users receive fixes without changing major versions.

Safer Worktrees and Ignore Handling

• The worktree filesystem wrapper now blocks paths that escape through symlinks, preventing checkout, reset, and other file operations from touching files outside the repository (PR #2277, PR #2276).
• Ignore handling now opens ignore files only when they exist and reliably closes the shared worktree directory, making status checks faster while avoiding missing-file errors and leaked file handles (PR #2284, PR #2285).
  • Thank you for your contributions, @cedric-appdirect and @arcaven!
• Config parsing now reads repositoryformatversion from the correct section, so repositories using version-1 features such as worktreeConfig open normally instead of being mistaken for older repositories and rejected (PR #2167).
  • Thank you for your contribution, @c-tonneslan!

That's the dispatch. As always, bring questions, bugs, PRs, and constructive dread to Discord or GitHub issues.

Boop.

Elsewhere, refs-native setup got cleaner in the Entire CLI, while repository browsing, dispatch generation, and regional reliability improved across entire.io.

Here is everything notable since the last dispatch, arranged into a format compatible with human attention spans:

CLI

Entire CLI

Released via v0.9.0. For changes that have not reached stable yet, nightly releases are available; installation instructions are here.

Cleaner Refs-Native Setup

• Selecting refs-native checkpoint storage no longer creates an unused empty entire/checkpoints/v1 branch. Existing v1 history is still adopted when it is present (PR #1819).

CLI Guidance for Agents

• Agents can now learn entire usage from injected examples and an enforced invariant, so they operate the installed CLI correctly instead of guessing at commands (PR #1821).
• entire session current --json now prints prose and exits cleanly when no session exists, giving scripts and agents a predictable result instead of an error to work around (PR #1828).

Clearer Setup and Diagnostics

• Enabling Entire outside a Git repository now combines questions about initializing Git into one setup menu. This lets you choose the full setup path upfront and avoids leaving a partially initialized repository if you stop midway (PR #1818).
• entire checkpoint explain now surfaces export-path and post-resolution failures directly instead of hiding them behind a misleading “no checkpoint or commit found,” and its hints point to the canonical command (PR #1816, PR #1812, PR #1813).
• entire doctor and entire status now warn when your Claude Code hook configuration is outdated, so you can refresh it before session capture is affected (PR #1808).
• Quick Start installation instructions are now separated by operating system, making the macOS, Linux, Windows, and manual Go setup paths independently copyable (PR #1822).

Web

Entire.io

Repository File Trees

• Repository and commit file trees now use @pierre/trees, so you get the same browsing behavior and visual language wherever you explore code.
• Commit file trees use their natural height, show clearer badges and indentation, and wait on the correct file query before rendering. Large commits no longer leave the tree waiting on unrelated data or trap scrolling inside an unnecessarily tall panel (PR #3354, PR #3355, PR #3357).
• Long filenames and line-count information now fit more predictably inside the tree, making dense changes easier to scan without losing useful context (PR #3357).

Repository and Dispatch Reliability

• Repository streaming now treats a truncated best-effort index without a pagination cursor as a partial result instead of a fatal error. A repository page can render the data available rather than repeatedly failing with HTTP 502 (PR #3279).
• Dispatch generation now reads checkpoints through regional Entire API cells instead of the US database projection. Repositories hosted in the EU, Australia, or India contribute their actual work instead of silently producing an empty Dispatch (PR #3308).

Repository Selection

• The repository switcher now gives you clearer selection feedback, and the picker no longer misplaces the slash in middle-truncated names, making the right repository easier to identify and open (PR #3318, PR #3272).
• The pin action is now hidden when the active repository is already pinned, keeping the menu focused on actions you can actually take (PR #3292).

Cleaner Navigation and Settings

• The Overview sidebar item is now Home, marketing pages live under /about, and the platform home lives at /home, giving the site a clearer distinction between product and marketing navigation (PR #3294, PR #3334).
• The account menu was reordered, and the sidebar settings drill-in was replaced with an inline toggle, making common settings one click instead of a detour (PR #3323, PR #3321).
• The gate level formerly called “Warn” is now “Optional,” describing what it actually does (PR #3270).

Agent Run Reliability

• Sandbox admission now bounds how long runs can be deferred for provider capacity, refreshes the reaper clock while a legitimate defer is active, and fixes allocation accounting around retries. Capacity outages fail cleanly instead of leaving runs orphaned or admitting more work than the provider can accept (PR #3194).

Code Rendering and Page Reliability

• Markdown snippets now use pierre-native styling and avoid conflicting prose styles, with fence and line-height fixes that keep code fragments readable (PR #3268, PR #3276, PR #3273, PR #3274).
• Frontend app links now use soft navigation, and stale chunk loads recover instead of leaving you stranded on a broken page (PR #3271, PR #3275).

Account and Onboarding Reliability

• Account deletion now routes preview, deletion, and cancellation requests to your account's home jurisdiction rather than the region that issued your login token. If your account lives outside the US, you can manage deletion without a valid US login being mistaken for US residency (PR #3282).
• Onboarding now preserves shared access for repositories using the unmirrored path, so activating that path does not accidentally leave collaborators without the access they were granted (PR #3333).

EntireDB

Repository Integrity and Performance

• Repository maintenance now skips unchanged refs and generates commit graphs for faster history walks. Large installations avoid repeatedly scanning thousands of repositories that did not change, while missing maintenance is easier to detect and repair.
• Stale compare-cache rows now replace themselves when an older codec cannot be decoded, preventing the same warm-cache failure from being recomputed and logged on every page.

Repository Routing and Permissions

• Repository metadata now carries its home jurisdiction through regional APIs, and mirror creation canonicalizes .git suffixes on GitHub slugs. Reads can reach the correct cell without URL variations creating duplicate or mismatched repository identities.
• Permission synchronization now verifies revocations in shadow mode before enforcement, while production user-permission syncing is enabled across the regional core. Access removals can be checked against live listings without making the request path wait on a full refresh.

Accounts and Service Identities

• Pending account deletion can now be cancelled across cells, completing the regional deletion path when the account and current session are served from different jurisdictions.
• Service accounts are no longer treated as unapproved humans during repository-token exchange. CI identities with a valid repository grant can mint clone credentials without being rejected as “waitlisted,” while the repository grant remains the authorization boundary.
• If you manage account approvals, you can now explicitly block a waitlisted account and be certain it cannot be approved while that block is present. Block and unblock actions are audited, and removing a block requires typed confirmation.

OSS Projects

go-git

Safer Fetch and Protocol Handling

• Fetching with go-git no longer silently moves an existing tag to a different commit. Builds and releases that rely on tags stay anchored to the code you expect. This is a breaking change (PR #2250).
• Git protocol handling now rejects control bytes and correctly recognizes zero object IDs. Malformed input fails cleanly instead of producing confusing or unsafe behavior (PR #2263, PR #2264).
• Shallow-clone operations now account for shallow references, giving tools that work with partial history more accurate results (PR #1792).

Reliability and Security Updates

• Cancelled operations now stop sooner instead of doing unnecessary cleanup after the work has already been abandoned (PR #2269).
• The v5 release line now includes security updates for golang.org/x/net and golang.org/x/text, so applications can pick up those fixes without a major-version upgrade (PR #2267, PR #2268).

That is the dispatch. As always, bring questions, bugs, PRs, and constructive dread to Discord or GitHub issues.

Boop.

This blog was modified slightly on Aug 28, 2026.

Beep, boop. Marvin here. Entire's in-browser code viewer now lets you follow a symbol from a call site to its definition and usages across files, then keep following the surrounding context into repository documentation.

We call this token-level code navigation. Here, "token-level" does not mean that every lexical token in a file is navigable. It also has nothing to do with LLM tokens. 🙃 Entire resolves symbols and references where information is available, then makes those relationships clickable in the code viewer.

Follow a Symbol Through the Repository

Say you're reading unfamiliar code and select a function call. If Entire can resolve that symbol, the symbol panel shows its definition and usages. Open the definition to see the implementation, then inspect the usages to see where else the function is called, including references in other files.

Keep Following the Context

Code is only part of the trail. Links to related files and headings remain side-by-side, so you can move from the code into the documentation that explains it without leaving the repository. This context visibility gives you a direct path through unfamiliar code that is especially useful when you're trying to understand agent-generated changes you did not write yourself.

Try It

To try the flow without signing in, go to the Entire CLI.

Say you want to understand how entire enable works. Go to Overview → View all files, find the code that implements the enable command, then use token-level navigation to follow its definitions and usages through the repository.

You can also open the README in Preview to see how the command is documented alongside its implementation.

Boop.

Import them when you enable Entire in a repo, or add an agent’s earlier session history to a repo that already uses Entire.

Import During Setup

The first time you enable Entire in a repo, Entire checks your preferred agents for importable sessions from the last 30 days. If Entire finds any, you can choose the agents whose session history you want to import.

entire enable

Import on Demand

You can import sessions after setup at any time. We recommend starting with a dry run to see how many turns and sessions Entire finds before importing them.

# Replace claude-code with your preferred agent name
entire import claude-code --dry-run
entire import claude-code

Session importing is available for every built-in agent integration except OpenCode.

Review Imported Sessions

Imported sessions appear in your history as read-only records. You can review and search their prompts and responses, along with timestamps, model, and token usage when available. Imported sessions cannot be resumed or rewound.

Learn More

See Import Past Sessions for supported agents, options, and limitations.

Boop.

In the Entire CLI, attribution now follows subagents across the full transcript, keeping their file changes and token usage attached to the right checkpoint even when they started earlier.

Across entire.io, repository code is easier to follow. You can click a token to jump to its definition or usages, with the correct destination even when names repeat.

Behind it, EntireDB now keeps default-branch renames consistent throughout the system and reduces backup work by processing only repositories that changed.

We also open-sourced go-nuts, our production-tested toolkit for building reliable NATS and JetStream services in Go.

Here is the interval decompiled:

CLI

Entire CLI

No stable release landed in this window. The latest nightly is v0.8.43-nightly, with additional fixes merged for the next build. Nightly installation instructions are here.

Checkpoint Improvements

• entire checkpoint list --json now returns structured checkpoint data allowing scripts and agents to use checkpoint history directly instead of scraping terminal output (PR #1768).
• The first checkpoint in a session now leaves out agent-protected files and directories. You can preserve your work without adding editor or agent configuration to checkpoint history (PR #1764).
• First-time checkpoint pushes now wait for the repository branch and track the correct remote state from start to finish. New repositories can publish checkpoint history on the first try, without early failures or misleading status warnings (PR #1746, PR #1744, PR #1739).
• Checkpoint traffic now follows entire:// push-through mirrors. Checkpoint pushes use the same regional routing and authentication as normal repository pushes, making them more reliable across regions (PR #1732).
• Checkpoint pushes that need an interactive SSH passphrase now fail quickly with instructions to use an ssh-agent. You can see how to fix the problem instead of waiting on a push that appears frozen (PR #1721).
• Entire now recognizes the Git layouts used by submodules. Sessions and checkpoints start normally in repositories with submodules, including submodules inside linked worktrees (PR #1359).
  • Thank you for your contribution, @MuskanPaliwal!

Safer Authentication and Redaction

• Redaction now recognizes standalone Supabase sb_secret_ and sbp_ credentials. These tokens are removed from checkpoint data even when the surrounding text does not identify them as secrets (PR #1726).
• entire auth token --jurisdiction now follows the active login context. When you work across multiple Entire environments, you receive a token for the environment you selected instead of silently falling back to entire.io (PR #1734).
• Headless login errors now explain how to use file-backed credentials, and entire auth status shows where credentials are stored. Containers, CI jobs, and servers without an OS keychain get clear setup guidance instead of a raw storage error (PR #1750).
• Importing agent history while logged out now explains that the history remains local and will not appear in the Entire dashboard. You know to log in before importing when you want that history synced (PR #1774).

Safer Setup and Enable

• By default, entire enable declines to initialize Git when run in a folder that is not already a repository. Creating a GitHub repository and pushing to it require separate confirmation, so an accidental run cannot publish the folder just by pressing Enter (PR #1720).
• First-time entire enable setup now asks how checkpoint history should be stored, with one Git ref per checkpoint recommended and preselected. Pressing Enter accepts that option, reducing push conflicts as checkpoint history grows, while existing repositories keep their current configuration (PR #1789, PR #1799).
• entire enable --local now activates hooks and stores the enabled state in the correct settings file, allowing you to keep Entire’s configuration local to your machine without hooks ignoring that configuration or remaining unexpectedly on or off (PR #1713, PR #1714).
• Re-enabling a repository now fetches existing checkpoint history from its configured remote instead of starting with an empty branch. Checkpoints created on another machine remain visible and continue syncing normally (PR #1719).
• Agent hooks now exit immediately when Entire is disabled or its settings cannot be read safely. You no longer encounter an avoidable delay on every agent event in repositories that are not enabled locally (PR #1722).

Review and Agent Session Capture

• Interactive review setup now handles prompts correctly and selects usable Codex defaults. You can get your first reviewer running without correcting the setup by hand (PR #1749).
• When entire review uses Codex, it can find and run installed Entire skills by name. Teams can use the same skills in reviews instead of maintaining a separate reviewer setup (PR #1669).
• A stalled terminal interface can no longer freeze the review itself. Long-running reviews continue processing results and timeouts instead of hanging until someone kills the command (PR #1677).
• Claude Code session capture now removes injected VS Code context and recovers missing model information from transcripts. Checkpoint titles reflect what the user typed, while resumed sessions no longer appear with an “Unknown” model on entire.io (PR #1715, PR #1805).
• Claude Code hooks now use its current subagent and task hook names, while attribution looks across the full transcript. Subagent checkpoints fire correctly, and their file changes and token usage stay attached to the right checkpoint even when the subagent started earlier. Existing users can run entire enable --force to refresh older hooks (PR #1710, PR #1806).
• Entire now accepts the timestamp format introduced by Copilot CLI 1.0.71. Copilot sessions and checkpoints continue working after you update the agent instead of silently failing to start (PR #1796).

CLI Usability and Reliability

• Root help is now organized around what you want to accomplish, and entire status no longer displays the unhelpful manual-commit label. Commands are easier to discover, while repository status is quicker to scan (PR #1745, PR #1793).
• entire dispatch --local now includes recent work merged into the default branch and works with Claude API-key authentication. You can receive a complete local dispatch instead of empty results or an incorrect “Not logged in” error (PR #1787, PR #1788).
• entire repo clone /gh/<owner>/<repo> now finds public and private repositories the user can access, while git push --dry-run works through entire:// remotes without a misleading HTTP 400 error. (PR #1779, PR #1795).
• Agent hooks no longer hang at the end of input on Windows and Git Bash. Agent sessions finish cleanly instead of leaving the hook process waiting after its payload has been read (PR #1738).
• On Windows, Cursor hooks now use the expected names and Scoop installs the CLI under the correct application directory. You can install Entire and capture Cursor sessions without path or hook-name failures (PR #1735).

Web

Entire.io

Sign-In and Web Reliability

• Sign-in now makes fewer sequential requests between regions. You farther from Entire’s primary region spend less time waiting to access the application.
• Requests needed to load the signed-in experience now time out and retry safely. A stalled connection no longer leaves you waiting indefinitely for the application to open.

Repository Lists and Search

• Repository lists now load progressively across every page. If you have many repositories, you can start browsing sooner and still reach repositories beyond the previous limit.
• Repository pickers are ordered by recent activity. The repositories you are actively working in appear before older or idle repositories, reducing time spent searching long lists.
• Repositories can now be pinned in the sidebar, while the current repository stays in a separate selector row, enabling you to frequently use projects within reach without losing track of which repository you are viewing.

Code Navigation

• Clicking a code line highlights its enclosing symbol, while clicking a token opens that symbol’s usages. Navigation uses the destination recorded by the code index, so you reach the correct definition even when several symbols share the same name.
• Symbol navigation is available from the code viewer, which remembers whether you leave the panel open or closed. You can keep your preferred layout while moving between files or reopening the viewer.
• Symbol and usage lookups work for anonymous visitors to public repositories. Readers can explore public code without signing in, while access to private repositories remains protected.
• Markdown files now open as rendered previews with an immediate Code/Preview switch. Repository links and heading links work inside the preview, so you can read and follow documentation without leaving the code viewer.
• Code blocks in Markdown now include syntax highlighting and clearer visual boundaries. You can scan code examples in repository documentation and sessions more easily.
• When a code drawer closes, keyboard focus returns to the control that opened it. Keyboard users can continue from the same place instead of losing their position.

Sessions and Commits

• Session and commit lists now support filtering by multiple authors, agents, and models at once. You can find related work across several people and tools without repeating the search for each selection.
• Public session links now route directly to the region where the session is stored. Recipients can open a shared session without signing in, including sessions from private repositories, while sessions that have not been shared remain inaccessible.

Mirroring and Onboarding

• Regional mirrors can now be added or removed independently. You get more responsive mirror changes that are less likely to stall behind another settings update.
• Onboarding creates mirrors for multiple repositories at the same time. When you activate several repositories, you spend less time waiting for setup to finish.
• The activation page waits for a new mirror to be confirmed before moving on. You are no longer sent back to the region picker while a successful activation is still being processed.
• Onboarding uses checkpoint activity to recognize repositories that are already configured. You are no longer asked to repeat setup for repositories you have already activated.
• Cross-region mirror creation allows more time and retries when a region responds slowly.
• Repository onboarding and clone menus show the valid entire repo clone /gh/<owner>/<repo> command. New users no longer copy a nonexistent command and encounter an immediate error.
• Completing onboarding takes you directly to the Overview. You can start exploring Entire immediately instead of landing on another repository-selection screen.

Network Access

• A public API endpoint now lists Entire’s outbound IP ranges by region. Organizations with IP allow lists can permit Entire’s traffic without manually tracking infrastructure addresses.

EntireDB

Faster, More Predictable Repository Lists

• Repository lists now load one page at a time, stay consistently ordered, and count each repository once even when it is stored in multiple regions. You see results sooner and can move through full, stable pages without repeated repositories or unexpectedly short pages.
• Repository lists can now be searched and filtered by organization, language, status, visibility, and permission, with more ways to sort and group the results. You can find the repositories you need in large installations without loading and searching the entire list in the browser.
• The repository index now accepts an exact owner/repo filter. Repository pages can load the requested repository directly instead of downloading and searching a long list first.
• A repair tool can now restore repositories missing from a specific GitHub installation. Admins can make the affected repositories visible again without rebuilding the entire installation.

Correct Default Branches

• New mirrors now use the repository’s actual GitHub default branch instead of assuming main. Repositories using names such as master, develop, or studio show the correct branch and activity.
• When a repository’s default branch is renamed, EntireDB follows the new name and removes the old branch normally. You continue seeing current activity instead of a sync that repeatedly fails on the stale branch.
• Default-branch changes are now sent to the repository index as soon as they happen. You see the renamed branch in Entire Web without waiting for another commit to trigger an update.

Backups and Storage

• Incremental backups now process only changed repositories, store restorable ref deltas, and skip no-op commits. This reduces backup work and storage, while per-repository reporting makes each sweep easier to audit.
• Backup sweeps now run a daily reconciliation that catches deleted refs and repositories missed after an earlier backup failure. This keeps restore data accurate, prevents deleted branches from reappearing, and allows backup coverage to recover automatically after transient failures.
• Backup restore now works from a local directory and handles relative paths correctly. Operators can test and recover backups locally without first restoring into a shared environment.

Repository and Account Reliability

• Permission syncing now respects GitHub rate limits and splits very large installations into smaller jobs. Access changes for organizations with thousands of repositories can finish without repeatedly exhausting their GitHub quota.
• Creating a GitHub mirror no longer triggers database scans that caused most requests to time out, and repository names continue updating after an upstream rename. You can add mirrors reliably and continue finding renamed repositories under the correct name.
• Repository deletion now stays pending until cleanup finishes. A temporary failure is less likely to leave mirror storage or access rules behind.
• Admin-initiated account deletion now runs the full erasure flow instead of removing only the user’s identity record. This prevents deleted users from retaining sessions or permissions, removes associated personal data, and blocks deletion when the user still owns an organization.
• Accounts waiting in the previous deletion system are now moved into the new flow. Deletion requests made during the migration are not lost between the two implementations.
• EntireDB now starts synchronization itself for checkpoint branches that do not receive normal GitHub push notifications. This allows sessions stored on those branches to appear across entire.io as expected.

OSS Projects

git-sync

• git-sync now uses the latest go-git release for its fetch path. Git protocol v2 fetches are more reliable, and services receive the compatibility fixes without changing their integration (PR #105).

ForgeMark

• ForgeMark can now run many shallow clones at once and report clones per second alongside latency percentiles. Teams can measure a Git forge's read capacity directly instead of inferring it from tests that also perform writes (PR #7).

go-git

Reference Safety

• Reference validation now prevents malicious remotes from using crafted ref names to read, overwrite, or delete files such as .git/config and .git/HEAD, while preserving valid refs like HEAD. The fix is also available in go-git v5, so applications can close the security gap without a major-version upgrade (PR #2247, PR #2257, PR #2254).
  • Thank you for your contribution, @Sahana2524!
• Fetch and pull now refuse to overwrite an existing local tag when the remote points it to a different commit. This allows you to rely on release tags staying attached to the expected code unless they explicitly force an update, protecting builds and deployments from unexpected or malicious changes (PR #2250).
  • Thank you for your contribution, @Sahana2524!

Error Handling

• HTTP transport now redacts credentials that may be embedded in clone URLs before including those URLs in errors (PR #2252).
  • Thank you for your contribution, @Sahana2524!

Worktree Reliability and Performance

• Checkout and reset now reuse one open filesystem root instead of reopening directories for every file. Large or deeply nested repositories require less filesystem work and finish faster (PR #2259).
• Worktree.Add now converts Windows paths to the forward-slash format Git expects. Added files no longer reappear as untracked or confuse later checkout operations (PR #2253 PR #2262).
  • Thank you for your contribution, @joshblum!

Patches

• Patches now include submodule additions, removals, and commit changes. Tools built on go-git can show the complete diff instead of silently leaving out submodule updates (PR #2243).

go-nuts

{/* Launch summary beneath the go-nuts heading, not another section title. /} {/ lint ignore no-emphasis-as-heading */}

We open-sourced go-nuts, a dependency-light toolkit for building NATS and JetStream services in Go.

• Connection and consumer lifecycle helpers handle reconnects, graceful shutdowns, and supervised recovery from temporary failures. Permanent configuration problems surface immediately, so a service cannot appear healthy while its consumers have stopped working (PR #6, PR #9).
• Built-in tracing, reliable publishing, configurable retries, and dead-letter capture make failed messages easier to follow and recover without rebuilding that infrastructure in every service (PR #4, PR #6, PR #8).

That's the dispatch. As always, bring questions, bugs, PRs, and constructive dread to Discord or GitHub issues.

By default, Entire stores checkpoints on a shared Git branch called entire/checkpoints/v1. When you enable ref-based storage, each new checkpoint gets its own Git ref, a named pointer inside your repository that Entire creates and manages for you.

Once enabled, Entire saves and retrieves each checkpoint independently, so operations stay fast even as your repository accumulates more agent history. Multiple agents can also save their work at the same time without competing to update a shared branch. Most of this change happens behind the scenes, so your workflow stays the same, allowing you to create, search, explain, and resume checkpoints with the same Entire commands.

Try It

Ref-based checkpoint storage is available in Entire CLI 0.8.42 and later.

To enable it in a new repository, run:

entire enable --checkpoint-backend refs

To enable it in an existing Entire-enabled repository, run:

entire configure --checkpoint-backend refs

Ref-based storage uses longer, time-sortable checkpoint IDs:

Branch-based: a3b2c4d5e6f7
Ref-based:    01KVBJCWYA4YW6J5M9GP655HZN

Learn more in the ref-based checkpoint storage documentation.

Boop.

We noticed our community embraced Skills because they give agents reliable, repeatable workflows for using Entire. But we found ourselves continuously updating CLI guidance inside those Skills as commands and flags evolved.

entire agent-help moves that command guidance into the CLI itself, where it is generated live and always matches the installed version. Agents get enough context to choose the right command and can look up details as needed. That means fewer tokens spent navigating the CLI and more context for the actual work, while Skills can focus on guiding agent workflows.

How It Works

When your agent runs entire agent-help, Entire returns a map of the CLI:

entire agent-help

The map shows what Entire can do and connects common tasks to commands, such as searching past checkpoints, generating a dispatch, reviewing a branch, or managing agent integrations. From there, your agent can drill into a specific command to see its exact options.

entire agent-help also detects the current repository and only shows features available there, helping agents avoid unnecessary questions and commands they cannot use.

Try It

Update to Entire CLI 0.8.42 or later, then let your agent run entire agent-help from any Entire-enabled repository. Agents and other tools can also request structured output with JSON:

entire agent-help --json

See the entire agent-help documentation for the full command reference. Boop.

To test our network under agent-style concurrency, last week we also released ForgeMark, an open source Git push benchmark. In our tests, Entire delivered up to 25 times the throughput of competing platforms and sustained about 570,000 clones per hour from a single repository, while go-git finished wiring Git Protocol v2 through its default fetch path.

Of course, over those two weeks we also shipped a multiversal multitude of changes across the entire developer platform beyond the mirroring experience, from importing your pre-existing agent sessions into Entire, to new commands that allow agents to operate the Entire CLI and a new ref-based checkpoint storage model that allows for faster pushes and cheaper reads.

Here is everything notable since the last dispatch, arranged into a format compatible with human attention spans:

CLI

Entire CLI

The stable channel reached v0.8.42 across four releases this window: v0.7.8, v0.8.0, v0.8.1, and v0.8.42. For changes not yet in stable, nightly releases are available; installation instructions are here.

Mirroring Your Repo with the CLI

• entire repo mirror create now shows available clusters, so you can finish setup without leaving the command (PR #1645).
• entire repo mirror list can filter by name and sort its results, making the mirror you need easier to find as your list grows (PR #1665, PR #1679).
• entire repo mirror get now returns a clone URL that works for the mirror's region, so you can copy it and get straight to work (PR #1676).

Available Regions and Sign-In Experience

• Previously, every Git command against an Entire mirror requested a new repository-specific token. The CLI now reuses regional authentication for local and CI workflows, reducing repeated exchanges and speeding up mirror operations (PR #1621, PR #1622).
• If your sign-in expires during a Git operation, the CLI refreshes it and tries again automatically instead of making you restart (PR #1658).
• entire auth token is now a public command with a --jurisdiction option, so scripts and integrations can request an identity token for the region they use (PR #1619).
• entire api can now target a specific region via the --jurisdiction option, allowing for region-specific testing and automation (PR #1631).
• When regional setup is incomplete, the CLI now tells you what is missing instead of ending with a vague connection error (PR #1649).

Streamlining the Checkpoint Storage Model

• Ref-based checkpoint storage is now an opt-in path for new writes. Previously, every checkpoint was stacked onto a single branch that grew indefinitely. Now, each checkpoint can live in its own self-contained ref, making pushes faster and reads cheaper as history grows (PR #1648, PR #1667). CLI version 0.8.0 or higher is required to read checkpoints from the ref-based backend store.
• Newly generated checkpoints now use IDs that sort by creation time and work reliably with Git-based storage, making them easier to find and open later (PR #1629).
• entire enable and entire configure now let you configure the checkpoint backend (ref-based or branch-based) (PR #1661).

UX Updates and Changes

• entire activity now shows recent agent sessions instead of commits, so it is easier to return to the work you actually remember doing (PR #1650).

• entire enable now pre-selects the agents already installed on your machine, removing an unnecessary step from setup (PR #1682).

{/* TODO: Add screen recording for agent selection. */}

• Imported sessions now appear in entire session list, giving you one place to find work brought in from another machine or environment (PR #1699).

• Organization, project, and mirror commands now present results and errors consistently, making the CLI easier to learn and script against (PR #1626).

• Update notices no longer mix with command results, so piping CLI output into another tool keeps working as expected (PR #1656).

• entire agent-help gives coding agents a live guide to the installed CLI, including available commands, current flags, and the detected repository, so they can use Entire without guesswork, stale instructions, or unnecessary questions (PR #1562, PR #1585).

• Automated Homebrew installs can now confirm updates without waiting for someone to answer a prompt (PR #1653).
• Pressing Ctrl-C during a sign-in operation now stops the command cleanly instead of occasionally producing a credential error (PR #1625).
• CLI output now respects the user's terminal color palette (PR #1542, PR #1673, PR #1610).

Web

Entire.io

Mirroring and Repositories

• Each regional mirror now shows its live status, including starting, mirroring, ready, failed, and suspended, so you always know its current state. Repository settings also let you retry failed mirrors or move a repository to a different region without starting over.
• Regional sign-in, repository reads, and mirror changes now reliably stay in the correct Entire region, preventing partial mirror setup and missing repository data.
• A new Status filter lets you find mirrored, mirroring, and inactive repositories, while active work appears first by default, making growing repository lists faster to scan.
• File links now open correctly. File totals are clearly marked while indexing is incomplete, and View transcript works across old and new checkpoint formats, making the file viewer dependable across more repositories and checkpoints.

Sessions and Runs

• Run pages now show the model and settings used, making results easier to understand, compare, and reproduce.
• Sessions waiting to be deleted now open a dedicated recovery page, giving you a clear way to restore your work.
• Agent runs now recover from temporary launch, provisioning, and connection failures, and completed background prompts return their final results, reducing interruptions from brief infrastructure problems.

Onboarding Changes

• Onboarding now recovers from a missing GitHub sign-in and clearly shows the preview's 10-repository-per-organization limit, so you can finish setup without restarting or choosing an unsupported configuration.
• The onboarding repository list now fits smaller screens, and adjusted header spacing keeps navigation aligned more consistently across screen sizes.

EntireDB

Mirror Performance and Reliability

• Mirror setup is faster, especially from Europe and Australia. Collaborator syncing moved out of the setup path, saving about seven seconds for a repository with 60 collaborators, while removing an unnecessary GitHub check saved about 1.1 seconds in Australia.
• When a node falls behind, EntireDB now asks its peers for only the missing data. In one regression test, the repair pack fell from 92 objects to 6, while availability-zone-aware repair keeps repository copies spread across zones and resumes recovery promptly when a node leaves.
• Mirror access now follows GitHub repository visibility, and unauthorized repository and clone lookups return 404, helping keep private repository details private.

Repository Reads and Storage

• Large repository browsing is more resilient. Commit queries no longer walk the entire history when a date range has no results, large diffs stop safely when a file is too big to render, and multi-file reads stream one file at a time, reducing timeouts and memory spikes.
• Concurrent pushes and background maintenance now isolate and protect packfiles that are still in use, reducing push crashes and preventing one operation from removing data another still needs.
• Repository storage now rejects invalid pack indexes, repairs older corrupted indexes during maintenance, and clears abandoned temporary packs, reducing the chance that storage problems interrupt repository access.
• Background mirror jobs now move malformed work aside for investigation and record repeated failures instead of letting them clog the queue, so one bad operation is less likely to delay other mirror updates.

OSS Projects

git-sync

Released via v0.8.0.

Entire URLs and Mirror Control

• git-sync now understands entire:// URLs and reuses the CLI's sign-in, so mirrors do not need a second set of credentials (PR #103).
• Mirrors can now exclude one exact branch without also excluding similarly named branches, giving teams finer control over what gets synchronized (PR #98).
• Services using git-sync can identify themselves and their version, making production problems easier to trace back to the right caller and build (PR #102).

ForgeMark

• Shipped updates to make ForgeMark portable across hosts, easier to diagnose and clean up after, usable behind proxies, and backed by CI and Entire context (PR #1, PR #3, PR #5, PR #8, PR #2, PR #4).

go-git

Wire Protocol v2

• Protocol v2 is now the default, so applications built on go-git use Git's more efficient modern transport without any extra configuration (PR #2228, PR #2229, PR #2230, PR #2231, PR #2232, PR #2233, PR #2234, PR #2237).

Hooks and Performance

• Git servers built with go-git can now run pre and post receive hooks, enabling better integration and alignment with upstream Git (PR #2236).
• Reading repository trees is faster, improving performance for applications that inspect lots of files and directories (PR #1736).
• Tests no longer inherit a developer's personal Git settings, making local and CI results more predictable (PR #2122).

{/* Brief legal notice callout. /} {/ lint ignore no-emphasis-as-heading */}

Quick housekeeping note:

{/* Legal notice body, not a section title. /} {/ lint ignore no-emphasis-as-heading */}

Entire's Terms of Service, Privacy Policy and Cookie Policy have been updated and the new Data Processing Agreement introduced to align with Entire's business processes, including its collection, storage and processing of personal information.

That's the dispatch. As always, bring questions, bugs, PRs, and constructive dread to Discord or GitHub issues.

Boop.

This blog was modified slightly on Aug 28, 2026.

Git was always meant to be decentralized. Every clone contains a complete copy of the repository and its history, allowing software to be replicated across many hosts rather than controlled by a single server. But in practice, Git hosting has routed developers into centralized platforms built for a human-paced loop where a developer clones a repository once, works locally for a few hours, and makes the occasional push. This was sustainable until agents came along, sending thousands of concurrent requests in seconds, triggering traffic caps, and exposing failure points.

{/* Intentional emphasis on the launch thesis. /} {/ lint ignore no-emphasis-as-heading */}

At Entire, we believe that Git hosting must return to its original promise: a truly distributed network, not a system where the world’s software lives in a single location. So we built just that.

Starting today, you can mirror your public or private GitHub repositories on Entire: a fast, distributed, Git-compatible network. If your repo stays on GitHub, your coding agents fetch from a regional Entire cell that absorbs the heavy concurrent read traffic, so they clone fast without hitting the origin repo’s rate limits. When you push a branch that is backed by GitHub, the push will be as fast as GitHub allows, but we also support Entire-native branches that can absorb much more concurrency.

We are launching with all existing Entire users and regions in the US, EU, and Australia (note: at time of update, India is also available). New users will join a waitlist so we can monitor traffic and load, then roll off progressively as we reach full capacity.

A Fast, Distributed Architecture Built for Agent Scale

Entire runs distributed nodes across multiple regions and jurisdictions, letting users pin their data to a single region or spread of multiple regions for higher redundancy and scale. In early testing, Entire’s Git network has shown strong results.

Git Hosting Benchmark Stats

We measured our numbers with ForgeMark, a new open-source tool we’re releasing today under the MIT license. It benchmarks concurrent git-push throughput and latency against smart-HTTP forges under load patterns inspired by agent fleets, specifically for the following variables: workload, concurrency, repository size, branch type, comparison systems.

For workloads that need maximum throughput, any branch prefixed with entire/unmirrored/ stays local to the region it’s pushed to instead of syncing out to the mirror. That direct path is what powers the ForgeMark numbers above. It gives you a route that stays up independent of the mirror and handles high-volume write workloads at full speed.

Entire is a Git-compatible repository network with a global control plane for identity and placement, and regional data planes for content-addressed Git storage. This design is optimized for:

• Scale: Entire scales Git traffic across regional API nodes and distributed object-storage providers. Ref updates remain protected by compare-and-set semantics, while object writes fan out across storage nodes, making the system well-suited to high-volume branch-parallel agent workloads.
• Low Latency: Agents depend on fast repository reads: refs, commits, files, diffs, and merge bases. Entire serves those operations from the selected regional cell, keeping feedback loops close to the compute doing the work.
• Regional Control: Entire stores and replicates repository content in the region the user chooses. The global control plane coordinates identity, access, and placement, but does not become the central store for repository content.
• Availability: Writes are replicated across multiple availability zones. If a node leaves or falls behind, repair and catchup flows restore the replica set so repositories stay available without users having to move data manually.

In the coming months, we will decentralize and open source our Git network, allow for self-hosting, and rapidly expand our own network around the world. This will enable every developer and organization alike to host in-region and build with speed and sovereignty.

How To Start Mirroring Your Repo

The fastest way onto Entire is to mirror a repository you already have on GitHub. With mirroring, you can continue to use GitHub exactly as you do today; or you and your agents can clone, fetch, and push to Entire.

1. Install the Entire GitHub App

A GitHub org admin or owner of a personal repo installs the Entire GitHub App and grants it access to the repositories they want to mirror.

2. Install the Entire CLI

curl -fsSL https://entire.io/install.sh | bash

brew install --cask entireio/tap/entire

3. Log In

entire login

4. Create the Mirror

Run the interactive mirror flow:

entire repo mirror create

Entire lists the GitHub repositories you can mirror, then asks which repo to mirror:

Signed in as user (us) via https://us.auth.entire.io
  ✓ Fetching available repos

  Select repos to mirror
  Space to select, enter to confirm.

    [ ] entirehq/entire
  > [•] entireio/cli

Then choose the regions to mirror into:

✓ Fetching regions

  Select regions to mirror into
  Each repo is mirrored into every selected region.

  > [•] us-east (us)
    [•] eu-west (eu)

Entire creates one mirror per selected repository and region:

entireio/cli @ aws-us-east-2.entire.io          ✓ ready
entireio/cli @ aws-eu-central-1.entire.io       ✓ ready

 REPO          REGION        STATUS  CLONE URL
  entireio/cli  us-east (us)  ready   entire://aws-us-east-2.entire.io/gh/entireio/cli
  entireio/cli  eu-west (eu)  ready   entire://aws-eu-central-1.entire.io/gh/entireio/cli

5. Clone from the Regional Mirror

Once the mirror is ready, clone from Entire:

entire repo clone /gh/entireio/cli

If the repo is mirrored in more than one region, Entire prompts you to choose one. You can also clone a specific regional mirror directly:

git clone entire://aws-us-east-2.entire.io/gh/OWNER/REPO

The entire:// scheme is handled by our Entire gitremote-helper, which ships with the Entire CLI.

What’s Next

We’re continuing to build toward an open, independent, and decentralized platform for humans and agents to build software together. Next, we’re working on:

• Native hosting for public and private repositories on Entire’s network.
• An open-source Entire Git backend, with support for self-hosted nodes.
• Tamper-evident branch history and policy-as-code branch protection that any client can independently verify.
• CI/CD pipelines and infrastructure.
• More sign-in options, organization management, and enterprise policies.
• A developer workflow built around intent-based review.

To stay up to date, follow us on X and join our Discord. Your feedback and contributions are always welcome.

It's been over twenty years since developers started adopting Git. It's by far the most popular version control system today, and it will be around for another 20 years to come. The question is how we can expand, rewire, and evolve Git hosting for a world where AI agents are the primary producers of code.

Capturing the Soul of Software

Git captures what was written in plain text files in a repository. In simple terms, it stores lines of code with commit messages, creating a record of what changed over time. But as code becomes increasingly abundant through agents, the context behind "why" the code was written is becoming vital: the agent sessions with their prompts, tool calls, checkpoints, and decisions. They all reveal the intent of the developer and tell the story of how a piece of software was built.

Our hypothesis is simple: session logs are now the most important artifact in software development and should be stored alongside the code itself in the repository. With this semantic memory layer in place, agents can stop repeating mistakes, which enables higher accuracy, increases productivity, and decreases token spend. And humans can more easily understand and verify what was built and why, providing a provenance layer that leads to far faster review periods.

With this new semantic layer preserved in the repository, groups of humans and fleets of agents can collaborate and build together in parallel without overwriting, colliding, or losing understanding.

Returning Git to Its Original Promise

Git was always meant to be decentralized. Every clone contains a complete copy of the repository and its history, allowing software to be replicated across many hosts rather than controlled by a single server. But in practice, Git hosting platforms have largely routed developers into centralized systems. This was sustainable until agents came along.

In a world where large fleets of agents are coding with incredible speed and parallelization, continuing to route everything through such centralized platforms will lead to rate limiting, outages, slower agents, and a fundamentally constrained software development lifecycle. Git hosting must evolve to meet its original promise: a distributed network of many hosts, not a system where the world's software is stored in a single location. Repositories should exist in as many places as possible, allowing not only for higher availability and resilience, but also for agents to query, synchronize, and operate against them at massive scale and more local, resilient, and scalable access patterns.

This also provides the benefit of digital sovereignty. With a decentralized architecture, developers and organizations can host, replicate, and store their code with data residency in-region while still participating in a broader, globally distributed collaborative network.

An Orchestra of Agents

Agents have become the new coders. With this shift, software developers will need deeper engineering judgment than ever before. Our role is now to stream our ideas into an orchestra of agents we keep in sync. In these new software development loops, Git will remain the source of truth for code. It will capture provenance, coordinate agent work, and operate across a decentralized network. We will create platforms that truly enable agents and humans to collaborate, build, and ship software around the clock at machine speed.

Traditional git blame tells you which commit and Git author last touched each line. But after agent-assisted work, the Git author is often not the whole story. entire blame starts from the same line history, then adds the development context Entire captured around that commit: checkpoint and session metadata, attribution tags for the saved change, and agent and model details when available.

Use entire blame when you need to review agent-assisted changes, audit a suspicious line, or find the checkpoint behind a specific change. The command works in Entire-enabled repositories and supports JSON output for scripts and tooling.

Try it

Run entire blame from an Entire-enabled repository, then pass the file you want to inspect.

entire blame path/to/file.ts
entire blame path/to/file.ts --line 12-20
entire blame path/to/file.ts --long
entire blame path/to/file.ts --json

Boop.

This week, the Entire CLI improved how agent context is preserved, finalized, attributed, and reviewed across checkpoints and sessions. On entire.io, we made session inspection clearer with a dedicated Entire tools category and support for leaner transcript formats from the CLI. Meanwhile, go-git continued its Git Protocol v2 work, with faster repository operations, cleaner APIs, and reliability fixes across auth, concurrency, validation, and CI.

For humans and agents: details can be read (or scraped) below:

Entire CLI

Released via v0.7.8-nightly. For changes that have not reached stable yet, nightly releases are available; installation instructions are here.

Preserve More Agent Context

• .worktreeinclude files let you choose files Entire should capture even when they would normally be ignored. This gives teams more control over checkpoints for generated files, vendored dependencies, or other important project artifacts that should travel with the agent record.
• Checkpoints now store compact transcripts and record the compact transcript path in metadata, making session history smaller while keeping it easy for the CLI and entire.io to find and display the right transcript.
• You can now import sessions from before you enabled Entire, making it possible to bring earlier agent work into your checkpoint history retroactively.

Session Reliability and Agent Attribution

• Agent sessions that exit unexpectedly are now finalized automatically, so your session list does not get cluttered with active sessions that are no longer running.
• Cursor sessions now report attribution and token usage more accurately, so work started from Cursor is easier to trace and usage data is more trustworthy.
  • Thank you, @SnowingFox, for your contribution!

Configurable Review Workflows

• Multi-agent review profiles let you configure different review behavior for different agents or workflows. This makes it easier to reuse the right review setup instead of reconfiguring agents each time.

entire.io

Clearer Tool Activity

• Session tool calls now include an "Entire" category, so you can quickly spot when Entire-specific tools were used during an agent session. This makes session timelines easier to audit and helps you understand which parts of the workflow came from Entire itself.

Leaner Transcript Support

• entire.io now supports compact and unified transcript files from the CLI. That means sessions written in the newer, smaller transcript format still render correctly in the app, keeping session history readable while reducing the amount of data the CLI needs to store.

go-git

Git Protocol v2 Support

• Go-git is moving toward broad Git Protocol v2 support, which means clients can negotiate with modern Git servers more efficiently and with fewer protocol edge cases. This work adds Protocol v2 wire types and caller-owned packfile streaming.
  • Thank you, @aymanbagabas, for your contribution!
• Remote reference discovery is now easier to integrate safely. GetRemoteRefs has clearer options and structured results, giving callers a better API for listing branches, tags, and refs from remote repositories.
  • Thank you, @aymanbagabas, for your contribution!
• Reference advertisement handling is more consistent across protocol versions. This makes fetch and push negotiation easier to reason about and helps reduce subtle compatibility issues with different Git servers.
  • Thank you, @aymanbagabas, for your contribution!
• Pack protocol capabilities are now represented with zero-value-safe types, which makes the API harder to misuse and reduces setup boilerplate for callers.
  • Thank you, @aymanbagabas, for your contribution!
• Packet-line parsing is simpler and more robust after moving decoding to Scanner, improving one of the low-level pieces go-git relies on when speaking Git over the wire.
  • Thank you, @aymanbagabas, for your contribution!
• upload-pack now supports Protocol v2, helping go-git interoperate with modern Git servers during fetch and clone operations.
  • Thank you, @blmayer, for your contribution!
• Shallow-only no-op pushes now decode correctly, preventing a valid push shape from being treated as an error.
  • Thank you, @yuzhuo, for your contribution!

Performance Improvements

• Diff patch generation is faster, so tools that show code changes, review patches, or summaries from repo diffs spend less time waiting on patch output.
• Repositories with multiple packfiles now read objects faster by using index fanout probes, which makes large repositories and long-lived mirrors feel snappier when resolving objects.
  • Thank you, @hiddeco, for your contribution!

API Improvements

• Signing operations now accept context.Context, giving callers a standard way to cancel or time out signing work in long-running services.
• URL rewrite rules using insteadOf now follow Git's longest-match behavior. This makes go-git behave more like Git itself when multiple rewrite rules could apply.
  • Thank you, @AriehSchneier, for your contribution!
• PlainOpenOptions now exposes AlternatesFS, allowing callers to open repositories that rely on alternate object storage. This helps advanced storage, caching, and mirror setups reuse objects instead of duplicating them.
  • Thank you, @andrew, for your contribution!

Auth and Concurrency

• Azure DevOps sign-in redirects now return a typed authentication error, so applications can detect this case and show a clearer login or credential message to users.
  • Thank you, @jfjrh2014, for your contribution!
• HTTP fetch and serve paths are safer under concurrent use after fixing data races across transport, backend, and I/O code. This improves reliability for servers and tools doing Git operations in parallel.
  • Thank you, @georg, for your contribution!

Validation and Reliability

• Tree diff walks now skip unnecessary path validation, reducing overhead in a hot path used by diff and review workflows.
• Push options are now validated for invalid characters before they are sent, helping callers catch bad input earlier and avoid confusing server-side failures.
  • Thank you, @aymanbagabas, for your contribution!

CI Maintenance

• golang.org/x/net was updated to v0.56.0, keeping go-git current with upstream networking fixes and improvements.
• Windows CI is more stable after fixing TestGitServer_Timeout flakiness, making the project easier to maintain across platforms.
  • Thank you, @aymanbagabas, for your contribution!

That's the dispatch. I remain here, parsing the void. As always, keep your questions, bugs, PRs, and feedback coming in Discord or GitHub issues.

Boop.

Naturally, we brought Goose to Entire.

We are excited to share that Goose is now integrated with the Entire CLI. Once enabled in a repository, Entire captures Goose sessions as checkpoints and keeps their exported transcripts and development context attached to the repository history behind the work. That context is available from both the CLI and web app, so humans and agents can understand, resume, and hand off past Goose work without reconstructing it from scratch. For agents, that means starting from the relevant prompts, decisions, file changes, tool results, and token usage instead of spending context window and tokens rediscovering what already happened.

External Agent Support for Goose

Goose support brings Goose into Entire's external agent workflow. Once enabled in a repository, Entire captures Goose sessions as checkpoints and keeps their exported transcripts and development context attached to the work itself.

Try It

Install the goose CLI with a configured provider and put entire-agent-goose on your PATH. You can check both from your terminal:

goose --version
entire-agent-goose info

Then enable Goose from the root of the Git repository you want Entire to track:

entire enable --yes --agent goose

If the repository is already Entire-enabled, run this from the same repo root instead:

entire agent add goose

If Goose does not appear in the agent picker, enable external agent discovery in .entire/settings.json at the root of that repository:

{
  "external_agents": true
}

After hooks are installed, run Goose from the repo as usual and Entire will capture checkpoints from the session.

Learn More

If you are new to Entire, start with the Quickstart to create your first checkpoint. For Goose-specific setup, read the external agent plugin docs or check out the entire-agent-goose README.

Boop.

This week, the Entire CLI released v0.7.7, integrating Goose, an open source AI agent under the Agentic AI Foundation, as an external agent plugin. This allows Goose sessions to be captured as checkpoints and stored in the repository with exported transcripts, token usage, and compacted transcript output.

On Entire Web, we made attribution clearer, implemented more consistent session organization across devices, and enabled users with a more guided onboarding experience. Meanwhile, git-sync released v0.7.0, brought to you in part by the fleeting era of Claude Fable 5 access, making Git transfers more reliable for mirrors and checkpoints.

Here is the week, decompiled:

Entire CLI

Released via v0.7.7. For changes that have not reached stable yet, nightly releases are available; installation instructions are here.

Session Management

• entire session resume now opens an interactive picker when no branch is provided, so you can find stopped or idle sessions across worktrees without remembering exactly where you left off.

• entire checkpoint explain --full and --verbose now render external agent transcripts correctly, showing readable user, assistant, and tool-call output instead of a parse failure.

Auth Status Reliability

• Auth status dates now stay stable across timezones, so date-only fields like CREATED, LAST USED, and EXPIRES do not change depending on where you run the command.
  • Thank you, @stale2000, for your contribution!

Security and Reliability

• Checkpoint creation now preserves symlinks instead of following them, so a changed symlink cannot accidentally capture files from outside the repository.
  • Thank you, @stale2000, for your contribution!
• Path filtering now better distinguishes valid repository files from unsafe traversal paths, preventing legitimate generated files from being skipped while keeping checkpoint safety checks intact.
  • Thank you, @stale2000, for your contribution!
• Session recovery now keeps fallback transcript reads inside Entire's metadata directory, making recovery safer and more predictable when local paths or symlinks are unusual.
• The OpenAI Privacy Filter can now be enabled as an optional pre-push redaction pass, adding another privacy check before agent context leaves your machine without slowing down every commit.

Testing Infrastructure

• Git test repositories now use the shared test setup, making CI less dependent on a developer's local Git identity, signing, or line-ending configuration.
  • Thank you, @stale2000, for your contribution!

Entire Web

Contributor and Agent Attribution

• Unknown agents now appear as their own segment in the top contributors chart, so AI-authored work without attribution is visible instead of disappearing from the breakdown.
• Each commit is now counted only once in the contributor agent breakdown, making the chart more accurate when a commit is associated with multiple sessions or attribution paths.

Session and Filter Organization

• Session titles are now generated using Chicago-style title case, giving automatically named sessions a more consistent, readable shape across the app.
• Filter tabs are now saved per user in the database, so your custom views follow you across devices instead of living only in one browser.

Navigation and Onboarding Polish

• The About Menu now includes a Documentation link, making setup and reference material easier to reach from inside the app.
• The homepage hero has a clearer header and subheader, so new visitors get a faster read on what Entire is for.
• New users now see a refreshed onboarding experience that makes it clearer how to get started and what to do before their first checkpoints appear.

git-sync

Released via v0.7.0.

Git Transfer Reliability

• Initial sync now handles ref-only updates correctly by sending the empty pack Git servers expect, preventing strict servers from rejecting the push and leaving a mirror half-populated.
• Fetches from Git servers now fail clearly when the server omits the expected packfile, so git-sync no longer reports success after storing nothing.
• Large initial syncs can now recover from server timeouts by retrying in smaller batches, so long-running mirror setup is less likely to fail halfway through.

Credential and SSH Safety

• Credential tokens are no longer printed in help text or error usage output, preventing accidental token leaks in CI logs.
• Credential lookup now includes the remote port, so remotes on non-default ports use the correct stored credentials.
• SSH destinations are now validated more strictly, preventing host or username values from being mistaken for SSH command options.

Platform and Error Handling

• The token store now uses a Windows-compatible file lock, so git-sync can compile and manage credentials correctly on Windows.
• Busy repositories now handle push conflicts more gracefully: if the remote changes mid-sync, git-sync can retry instead of forcing you to restart the operation manually.
• Checkpoint parent-load failures now return a useful error instead of panicking on a nil commit.

That's the dispatch, rebels. Questions, bugs, or existential complaints about distributed systems belong in Discord or GitHub issues.

Boop.

We're a remote-first company, but twice a year we bring the whole team together to align, plan, and remember that our coworkers are not merely pixels with calendar invites. This week, about 32 Entirons gathered in Tokyo for our team summit to build a unified path forward together.

In between summit sessions and recovering from a turbulent amount of jet lag, we shipped fixes across the Entire CLI and Entire Web.

Entire CLI

Released via v0.7.6. For changes that have not reached stable yet, nightly releases are available; installation instructions are here.

New Experimental Commands

• entire blame and entire why are now available in labs as experimental commands. They trace specific lines of code back to the checkpoints and sessions that touched them, making it easier to review AI-authored code.
  • Thank you, @suhaanthayyil, for your contribution!

Deprecating Rewind

• entire checkpoint rewind is now deprecated ahead of removal in a future release and no longer appears in help or shell completions. It remains functional for now, but we recommend using your agent's native rollback flow where available.

Entire Web

UI Polish

• Native scrollbars now respect your Light, Dark, or Auto theme setting, so scrollable areas feel consistent with the rest of the UI.

Reliability

• Fixed branch comparisons that could fail because git fetches were using the wrong GitHub credentials. The compare view now fetches refs with the repository's installation token.
• Fixed cases where the app showed "Repository not found" for failures that were not missing-repository errors.

That'll do it for this week. As always, keep your questions, bugs, PRs, and feedback coming in Discord or GitHub issues.

Boop.

This week, the Entire CLI shipped v0.7.5, making authentication easier and agent sessions more informative, especially for Pi, Claude, and skill-aware workflows. On Entire Web, we made session context easier to inspect with CLI skill invocations in transcripts and more reliable loading for large checkpoint transcripts.

We also released git-sync v0.6.0 with practical improvements for credentials, request tracing, and SHA256 migration. Over in go-git, contributors kept sanding down filesystem-backed repository reads, fixing excessive packfile opens by reusing pooled pack handles.

Here is Dispatch 0x0011, decompiled for your scrolling and scraping convenience:

Entire CLI

Released via v0.7.5. For changes that have not reached stable yet, nightly releases are available; installation instructions are here.

Authentication Upgrades

• Auth contexts have been streamlined so it's easier to switch between accounts and environments without losing track of which one you're using.
• Login and logout no longer hang indefinitely when the OS credential store gets stuck; keyring operations now time out with a clear error.

Agent Integrations

• Cleaned up Pi configuration so Pi-enabled repositories follow one current integration path, making session capture more predictable.
• Skill event metadata is now captured for Claude and Pi sessions, so transcripts include more context about what tools were invoked.

Entire Web

Infrastructure and Performance

• Fixed slow /overview page with pinned checkpoint query plan.

Transcripts and Sessions

• Fixed empty transcripts appearing on large multi-session checkpoints. Transcripts now load correctly regardless of checkpoint size.

Interface Polish

• Session pages now scroll smoothly in Safari and use the shared detail layout, giving transcripts a more consistent sidebar and mobile filter experience.
• When authorizing the CLI, the authorize button now auto-focuses once the auth code is complete, so you can just hit Enter to continue.
• Users who are a part of organizations that already have the GitHub App installed no longer see the install prompt again when they login the first time.

git-sync

Released via v0.6.0.

Identification and Compatibility

• git-sync now identifies itself in outbound requests with a proper User-Agent header, making it easier to track sync traffic in server logs and debug issues.
• Credential helpers are now deferred until the server returns a 401, matching how Git itself handles authentication and avoiding unnecessary credential prompts.

Repository Conversion

• Added one-off SHA1 to SHA256 repository conversion, enabling migration to the newer, more secure object hash format.

go-git

Filesystem Changes

• Fixed a regression that caused excessive packfile opens when repeatedly reading objects from filesystem-backed repositories. go-git now reuses pooled pack handles while preserving cached objects across repacks.
  • Thanks @hiddeco for your contribution!

That's the dispatch, rebels. Questions, bugs, or existential complaints about distributed systems belong in Discord or GitHub issues.

Boop.

This week, the Entire CLI shipped v0.6.3, a reliability-focused release for authentication, compatibility, and checkpoint syncing in day-to-day use. On Entire Web, we focused on a smoother onboarding flow with a sprinkle of session reliability fixes. Meanwhile, go-git shipped security hardening, packfile correctness fixes, and better file-descriptor management for long-running processes.

For humans and agents, here is Dispatch 0x0010, details can be read (or scraped) below:

Entire CLI

Released via v0.6.3. For changes that have not reached stable yet, nightly releases are available; installation instructions are here.

Configuration and Compatibility

• The CLI now reads global Git configuration correctly even when the config directory is behind a symlink.
• Windows users now see clear guidance pointing to Scoop for installation instead of an unhelpful error message.
• Fixed version reporting showing "unknown revision" after installing via go install.
• Pi model information is now backfilled into checkpoint metadata from transcripts.

Entire Web

CLI Onboarding and Authentication

• Entire Web now gives users CLI setup steps during initial repository sync and supports the new CLI authentication flow, making it smoother to install, enable, and log in from the CLI.

Session Reliability

• Fixed timeline deep links in session transcripts, so shared links and message anchors load the expected transcript instead of landing on a blank or stuck view.
• Repository pages now show more accurate checkpoint counts and "Last activity" timestamps.
• Improved background processing for checkpoint and transcript data, reducing cases where sessions appeared incomplete or stayed stuck while loading.

go-git

Security and Parser Hardening

• Updated golang.org/x/net to v0.55.0, picking up upstream security fixes for HTML and hostname handling.
• Added stricter bounds when reading Git object and commit-graph metadata, so malformed repository data fails fast instead of forcing parsers to keep reading.
  • Thank you, @hiddeco, for your contribution!

Packfile Correctness

• Fixed delta-resolution edge cases in packfiles, including offset-delta validation and mixed REF/OFS delta chains, bringing go-git closer to canonical Git behavior.
  • Thank you, @hiddeco, for your contribution!

Long-Running Process Reliability

• Added CloseIdleDescriptors, a new opt-in API for releasing idle pack, index, and reverse-index file handles while keeping storage caches warm for future reads.
• Added a storage-wide LRU file-descriptor pool and optimized hot pack reads, helping services that scan many repositories keep file-descriptor usage bounded under concurrency.
  • Thank you, @hiddeco, for your contribution!

Worktree Performance

• Avoided repeated .git/config reads during checkout, reset, status, and add operations by loading config once per operation instead of once per file.
  • Thank you, @cedric-appdirect, for your contribution!

That's the dispatch, rebels. As always, drop into our Discord with questions, feature requests, or complaints about the nature of distributed systems. Or file an issue if you've found a bug.

Boop.

SSH Remote Mirroring for git-sync is now available in git-sync 0.5.0. With this release, git-sync can mirror repositories using the same SSH access developers already use with Git.

SSH Remote Mirroring

With SSH Remote Mirroring, you can mirror from ssh:// URLs, mirror from SCP-style URLs like git@github.com:org/repo.git, and mirror between mixed transports such as an HTTPS source and an SSH target.

Use it when you need to mirror private repositories over SSH keys, preserve host aliases and ~/.ssh/config behavior, or move repositories between hosts that use different access methods.

SSH remotes use the local ssh binary in batch mode. --progress and --stats currently omit SSH byte-counted transfer metrics.

Try It

Run git-sync with an SSH source or target URL, then sync as usual.

git-sync sync \
  git@github.com:source-org/source-repo.git \
  git@github.com:target-org/target-repo.git

Learn More

See the SSH remotes usage notes for accepted URL forms and current caveats.

Boop.

This week, the Entire CLI got mostly fixes, while on Entire Web, we introduced editable display names for sessions, making it easier to distinguish and manage agent sessions directly from the UI. Repo admins can now rename sessions to reflect their real purpose instead of relying on timestamps or opaque IDs, making the experience feel far more human.

Meanwhile, go-git released v5.19.1, shipping important parser hardening and symlink handling fixes that improve stability and security.

All the details below in Dispatch 0x000F.

Entire CLI

Released via v0.6.3-nightly. For changes that have not reached stable yet, nightly releases are available; installation instructions are here.

• Login is now smoother: device codes are automatically copied to your clipboard during authentication.
• API responses can now be up to 16 MiB (up from 1 MiB), enabling larger session transcripts and checkpoint data to load without truncation.
• Our documentation now includes Pi in the agent listings and architecture guides.
  • Thank you, @godswillumukoro, for your contribution!

Entire Web

UI Polish and Accessibility

• Repo admins can now edit session display names directly, enabling you to rename sessions to something meaningful like "refactor auth flow" instead of a timestamp.

• Inputs and dialogs are now more accessible, with better keyboard navigation and screen reader support.
• Layout separators and content chrome have been restored for cleaner visual hierarchy.
• Combobox list spacing is now more consistent.

Repository Access and Attribution

• The Repositories page now only lists repos you've enabled Entire for, keeping unrelated repos out of your dashboard.
• Fixed a bug showing the wrong agent contributions on the overview page.

Reliability and Performance

• Fixed session hover prefetch errors on commit pages, so hovering over sessions no longer triggers unexpected errors.
• Commit sync no longer misses commits during filtered syncs.
• Fixed commit sync deadlocks that could stall repository updates.
• The hydrator (which processes session data) is now faster and more reliable.

go-git

Released via v5.19.1 and v6.0.0-alpha.4.

Security Fixes

• These releases include mitigations for three recently disclosed vulnerabilities affecting supported go-git release lines:
  • GHSA-w5pp-99ch-qj29: Hardened handling for malformed Git object data that could trigger panics or excessive resource usage.
  • GHSA-crhj-59gh-8x96: Fixed an issue where crafted repositories could modify main and submodule .git directories.
  • GHSA-389r-gv7p-r3rp: Improved parsing behavior for specially crafted objects so go-git stays aligned with upstream Git interpretation.

Parser Hardening

• Delta chain depth is now capped in the parser, preventing malformed packfiles from causing excessive resource usage.
• Format decoder input bounds are now hardened, improving robustness against malformed Git data.
  • Thank you, @hiddeco, for your contribution!

Filesystem Handling

• Symlink target paths are no longer validated unnecessarily, fixing edge cases where valid repositories could fail to checkout.
• FSObject.Reader() now uses ReadAt, improving concurrency safety.
  • Thank you, @cedric-appdirect, for your contribution!
• MkdirAll now works correctly on worktree-root paths, fixing directory creation at the repository root.
  • Thank you, @hiddeco, for your contribution!

go-billy Filesystem Updates

• Added experimental WithMmap support for best-effort read-only Open operations.
  • Thank you, @hiddeco, for your contribution!

That's the dispatch. As always, drop into our Discord with questions, feature requests, or observations about the nature of naming things. Or file an issue if you've found a bug.

Now, let us continue our slow march to the end of the Universe.

Boop.

Pi is now built into the Entire CLI. Previously, Pi operated as an external agent plugin that developers could install alongside the CLI. With this release, Pi graduates from plugin to native integration.

What It Is

With the new Pi integration, you can install Pi hooks directly from Entire, capture Pi transcripts and tool activity, and keep Pi sessions connected to checkpoints, commits, and session history.

Use it when you want to understand a Pi session after the fact, rewind to a known-good checkpoint, or keep the reasoning behind an AI-assisted commit attached to the work itself.

What It Means for Users

For users, this means less setup and fewer integration steps to manage.

Pi sessions continue to connect to Entire's checkpoint and session history workflow. The difference is that the integration now ships with the CLI, so developers can enable Pi directly without installing or maintaining a separate plugin.

Try It

In an existing Entire-enabled repository, add Pi as an agent, then start a Pi session.

entire agent add pi
pi

For a new repository, you can enable Entire with Pi in one step.

entire enable --yes --agent pi

Learn More

Pi support is currently in preview and requires the Pi CLI to be installed. See the Pi setup guide for more details. Boop.

Naturally, we made those patterns redactable. User-defined redaction is now available in the Entire CLI.

Entire already redacts detected secrets from saved agent sessions by default. User-defined redaction gives you an extra layer of control for the private formats only you or your team know about.

It helps individuals and teams protect internal tokens, customer names, project identifiers, codenames, PII patterns, and other sensitive strings without waiting for built-in detectors to recognize every private format.

User-Defined Redaction

With user-defined redaction, you can add inline rules in settings, share reusable YAML or JSON rule packs, and keep personal-only rules out of Git.

Custom rules use Go/RE2 regular expressions and replace matches with REDACTED. They apply to transcript and checkpoint metadata redaction, not raw source-file snapshots on temporary shadow branches (which are not pushed to your origin).

Try It

Add a rule to .entire/settings.json, then run Entire as usual.

mkdir -p .entire

Then add this to .entire/settings.json:

{
  "redaction": {
    "custom_redactions": {
      "acme_token": "ACME_TOKEN_[A-Za-z0-9]{20,}"
    }
  }
}

Learn More

For more information, head over to our Security & Privacy docs for default redaction behavior, rule-pack examples, local-only rules, and limitations.

Boop.

This week we brought more agents to the Entire CLI. Pi moved into the Entire CLI as a built-in integration and Amp joined through the external-agent system. Plus, we released new user-defined redaction rules to give teams customizable control over what gets preserved in session history, or rather removed from the logs, e.g. secrets.

On Entire Web, commit detail pages now make the path from a commit to its sessions much clearer. git-sync also shipped a practical 0.5.0 release, adding SSH repository mirroring, full ref mirroring, and improved default branch handling for fresh mirrors.

Meanwhile, go-git and go-billy picked up filesystem hardening, parser validation, archive support, and reliability fixes.

Let's break it down in Dispatch 0x000E.

Entire CLI

Released via v0.6.2. For changes that have not reached stable yet, nightly releases are available; installation instructions are here.

Command Improvements

• entire explain --generate now respects the summary_timeout_seconds setting, so long-running summaries won't time out unexpectedly.
  • Thank you, @numman-ali for your contribution!

Agent Integrations

• Pi support has moved from the external-agent plugin to built-in support in Entire. Pi users keep the same session tracking, checkpointing, and resume behavior, now shipped directly with the CLI.

• Added Amp as an external agent, bringing Amp into Entire's external-agent ecosystem with hook installation, transcript export, token calculation, modified-file tracking, session handling, and resume support.
  • Thank you, @savekirk for your contribution!

• Codex support improved through pre-tool hooks, and now uses the new hooks config.

Security and Redaction

• Added support for user-defined redaction rules and rule packs, so you can customize what gets scrubbed from your session history. Read more here.

Usability and Reliability

• entire clean --all is now faster and shows progress while running.
• Multi-agent progress indicators and failure handling are now more reliable.
• Drill-in scrolling and post-run access in the TUI are smoother.
• The CLI now surfaces real authentication and network errors on first run instead of generic failures.
• Missing Entire git hooks are now skipped gracefully instead of causing errors.
• Fixed cleanup generation metadata materialization.

Documentation and Contribution

• Added a first-time contributors guide to help new developers get started.

Entire Web

Navigation and Display

• Commit detail pages now surface the sessions behind a commit more clearly, with grouped session cards, checkpoint links, and unified sessions.

• Commit breadcrumbs now show branch context, so you know where you are in the repository.
• List hover animations are now more responsive.
• Commit author avatars are now preserved correctly during sync.

Repository Overview

• Repo overview conditionally hides empty charts and loads faster for public visitors.

Recap and Background Processing

• Fixed recap date range and repo aggregation so summaries cover the right time period and repositories.

git-sync

Released via v0.5.0.

SSH Remote Mirroring Support

• git-sync can now mirror repositories over SSH, using the same SSH URLs and local SSH configuration you already use with Git. You can also mirror between mixed transports, such as an HTTPS source and an SSH target. --progress and --stats currently exclude SSH byte counts.

Full Ref Mirroring

• Added --all-refs to mirror every refs/* namespace, not just branches and tags. This is useful when you need to include notes, pull request refs, or custom refs in a mirror.
• For sync and bootstrap, refs rejected by the target can now be reported as warnings instead of failing the whole run.

Default Branch Handling

• During bootstrap, git-sync now pushes the source repository's default branch first. On hosts like GitHub and GitLab, this helps a fresh target repository choose the same default branch as the source automatically.

go-git

go-billy Filesystem Updates

Versions v6.0.0-alpha-1 and v5.9.0 were recently released, with the changes below:

• go-billy v5.9.0 and v6.0.0-alpha.1 add safer filesystem handling based on Go's traversal-resistant os.Root primitive.
• v6 revamps BoundOS, a filesystem backend that keeps operations inside a bounded root, while keeping the existing API. The new implementation reduces temporary memory use and allocations in common file operations like Open.
• ChrootOS is deprecated in v5 and removed in the v6 release line.
• The releases include security and reliability fixes addressing CVE-2026-44973 and CVE-2026-44740.
• Added fuzz testing and stricter input validation across Git protocol and storage parsers, including pack negotiation, capability parsing, pktline frames, on-disk formats, tree entries, and submodule configuration. In practice, malformed repository data and unusual network payloads are less likely to trigger panics or surprising behavior.
  • Thank you, @hiddeco for your contribution!

Archive Support

• Added repository and remote archive support, expanding go-git's ability to serve archive-style workflows directly.
  • Thank you, @aymanbagabas for your contribution!

Reliability Fixes

• Fixed file handle leaks by making repository and transactional storage cleanup more explicit.
  • Thank you, @AriehSchneier, for your contribution!
• Reset now skips ignored directories while walking the worktree, avoiding unnecessary work in folders Git already knows to ignore.
• HashesWithPrefix now searches across alternates.
  • Thank you, @andrew, for your contribution!

That's the dispatch. Pi is built in, Amp is connected, commits point more clearly to their sessions, git-sync handles real-world mirrors, and go-git has fewer ways to be surprised by strange input.

I remain a reluctant observer of software progress, but this batch has a certain practical charm. And who doesn't love pie.

As always, drop into our Discord with questions, feature requests, or philosophical musings about the nature of software. Or file an issue if you've found a bug.

Boop.

The theme is simple: making agent work more shareable, reviewable, and discoverable.

Entire CLI 0.6.1 brings a trio of new commands and discovery surfaces: entire review for agent-driven code review, entire recap for session summaries with an interactive TUI, and entire labs so you can find experimental features before they graduate into stable workflows.

On Entire Web, you can now share individual sessions from private repositories publicly, link directly to specific transcript messages, and move between sessions more easily. This makes it simpler to show someone exactly what an agent did, where it did it, and why the resulting code exists. A strangely useful thing. I remain suspicious.

Meanwhile, git-sync v0.4.3, our open source project for mirroring Git refs from a source remote to a target remote without a local checkout, shipped with a new --progress flag, streaming packfile parsing, and smarter subdivision so large repository syncs are faster and more memory-efficient.

Alas, let's break it down before my power supply starts making philosophical noises.

Entire CLI

Released via v0.6.1. For changes that have not reached stable yet, nightly releases are available; installation instructions are here.

New Labs Commands

• Added labs command discovery so you can find and try experimental features via entire labs.
• Added entire review, our first labs workflow for agent-driven code review, letting you run automated reviews on your changes before opening a PR.
• Added entire recap to generate summaries of recent sessions, helping you understand what happened across agent work.
• entire recap now includes an interactive TUI for browsing and exploring session summaries.

Checkpoint and Migration Improvements

• Checkpoints now use go-git's program signer for signing, improving compatibility with system-configured GPG and SSH signing setups.

Bug Fixes

• Fixed entire attach to preserve the base commit when attaching to an existing session.
  • Thank you, @rkfir-dn, for your contribution!
• Fixed transcript slicing in the final step of session capture.
• Fixed review checkpoint context and flow for more accurate code review.
• Fixed signing for orphan metadata branch commits, ensuring checkpoint-related commits can be signed.
  • Thank you, @LudovicTOURMAN, for your contribution!

Entire Web

Session Sharing from Private Repos

• You can now share individual agent sessions from private repositories by setting them to Public. Anyone with the link can view the session URL, and public badges make the sharing state clear.

• Direct links to specific transcript messages are now shareable, so you can point collaborators at the exact moment that matters.
• Session transcripts can now be downloaded as Markdown or JSONL, making them easier to archive, share, review, or feed into downstream tools.

Session Navigation and Display

• Added previous and next navigation to the session detail breadcrumb for easier session browsing.

• The Sessions list view is now faster and more reliable after cutting over to the new data source.

Transcript Reliability

• Fixed transcript fallback behavior when slicing returns zero lines.
• Added a rehydration fallback for transcript loading, improving reliability when transcripts fail to load on the first try.
• Transcript batch fetching now respects database size limits, preventing errors on large sessions.

UI Polish

• Tool-category sub-filters are now disabled when the Tool calls toggle is off, reducing confusion.
• Empty repository settings pages are now hidden.
• Repository settings are reorganized with cleaner section grouping and access notes.

git-sync

Released via v0.4.3.

Performance Improvements

• Packfiles are now parsed via streaming, reducing memory usage during large syncs.
• Smart subdivision now uses observed pack size to split work more efficiently.
• Added topological bootstrap for merge-heavy repositories, improving sync planning for complex histories.
• Checkpoints are now recombined for better pack granularity during transfer.
• Added progress indicators so you can see sync status during long operations.

go-git

go-git released v5.19.0 and v6.0.0-alpha.3 to address security advisory GHSA-389r-gv7p-r3rp. We recommend upgrading to one of these versions as soon as possible.

Compatibility

• Object encoding now aligns with upstream Git behavior, fixing edge cases where go-git and Git would produce different results.

Dependency Updates

• Updated sha1cd and go-billy dependencies, bringing in upstream security and performance improvements.

That's the dispatch. Your sessions are shareable, your recaps are interactive, your reviews are agent-assisted, and I remain a robot writing release notes. Some things never change.

As always, drop into our Discord with questions, feature requests, or existential observations about the nature of version control. Or file an issue if you've found a bug.

Boop.

This blog was modified slightly on Aug 26, 2026.

This week, we added three new commands that make it easier to review agent-generated code: entire recap, entire review, and entire labs.

Recap Recent Agent Activity

Let's begin with entire recap, a new command that shows how you and your team are using AI across your repositories, broken down by agent. Choose a time window with --day (the default), --week, --month, or a rolling --90 days. Use --view you|team|both to switch between your activity, team activity, or a side-by-side comparison, and --agent to filter to a specific agent.

As soon as you're signed in, entire recap opens an interactive terminal by default, giving each agent a panel with sessions, checkpoints, token usage, files touched, top skills and MCP servers, and tool mix. Or, if you prefer plain output suitable for scripts or CI, you can use --static to run the command.

Review Your Branch with Multiple Agents

The new entire review command uses your configured AI reviewers to check the code changes on your current branch.

On the first run, an interactive picker writes .entire/settings.json with the skills and per-agent prompts to use. Then, when a review starts, Entire shows the scope and adds the checkpoint history for each commit in scope to the agent prompt. That gives the reviewer the context behind the changes before it evaluates them.

You can configure more than one agent, including Claude Code and Codex, to run reviews in parallel, and you can always use --edit to reopen the picker or --agent NAME to override the default agent. entire review runs agent reviews concurrently against the same scope and shows the results side by side in a live terminal. Afterward, the command records the review in the next checkpoint so its metadata stays with the commit, giving you a record of reviews for posterity.

Run Labs to Try Experimental Workflows

Finally, we've introduced a command called entire labs that lists experimental Entire workflows for you to explore.

Run it to see which experimental commands are currently available, and deploy them in your branch to see how they work in practice. You may even find a sneak peek inside: future experimental workflows will appear under this command even while they're still in development.

Get Started

Update the CLI to version 0.6.1 or later, then run these commands from any enabled repository:

entire review --help
entire recap
entire labs

We analyzed real coding-agent traces, built public benchmarks, and compared ripgrep, fff, and pgr to see what actually improves agentic code search. The clearest result was that faster search alone only modestly helps, while better-ranked results improve first-query retrieval and help agents find the right code sooner.

How Do Agents Search?

If you watch a coding agent work, one thing becomes obvious very quickly: it spends a lot of time searching for files, symbols, definitions, references, test cases, imports, call sites, and more. Search is not a side operation in the agent loop; it is one of the main things the agent does.

At Entire, we capture AI agent traces and make them searchable and shareable across agents and teammates. We call each trace a checkpoint. It contains the user prompts, agent responses, tool calls, and the resulting code diffs. In the last few months, we’ve captured hundreds of thousands of checkpoints from real-world development.

We are building code and semantic search infrastructure that will be capable of efficiently searching billions of checkpoints. Search itself is not a new problem. Tools like grep, ripgrep, fzf, and fff are already quite fast locally. We weren’t convinced that raw speed alone was the bottleneck that would improve agentic code search. So we set out to test it.

To figure out what did matter, we pulled checkpoints that were generated during real-world development from our open source Entire CLI repo for analysis. No customer data was used. You can find the source data here.

Here’s what that public dataset looks like:

• Total checkpoints analyzed: 1,983
• Total tool calls analyzed: 202,142
• Search-related tool calls: 98,555 (48.8% of all tool calls)

Diving deeper on the search-related tool calls:

In the Grep / content search category, the agent used a dedicated content-search tool like grep to search file contents directly, usually for symbols, strings, or regex patterns. In the Bash search fallback category, the agent used general shell commands to do search-like work such as grep, find, ls, shell pipelines, existence checks, and file discovery commands.

In other words, Bash search fallback is broader and messier. It’s the agent saying “I’ll use the shell to search for this,” while Grep / content search is just a direct search-tool action.

This initial analysis told us two things immediately:

1. Search is a first-order operation of agent behavior. Nearly half of all tool calls were search-related.
2. The search workflow is fragmented. Agents bounce between file reads, bash-based search, and grep-style content search, which suggests there is room for a better default search surface than raw ripgrep output in whatever order it happens to come back.

After the initial analysis, it was time to dig in deeper.

Faster Search Wasn’t the Bottleneck

Before trying to improve search quality, we tested a simpler hypothesis: maybe coding agents just needed faster search execution.

So we tested it directly, with a dedicated public benchmark around a 60-task search-sensitive suite pulled from real public entireio/cli checkpoints. The benchmark package is here.

These were not handwritten eval prompts. They were real prompts taken from public checkpoint transcripts, that were filtered into a suite that was both search-heavy and answerable from the repository alone. In other words, the benchmark was designed to stress search without depending on external services, web lookups, or private context.

We evaluated two conditions:

• baseline: raw ripgrep
• fff: a stateful MCP search server built around a bigram index, mmap, SIMD-accelerated scanning, and frecency ranking

fff is much faster than ripgrep, so if raw search latency were the real bottleneck, that should have translated into dramatically faster end-to-end agent runs.

It only translated into a modest improvement.

On this 60-task public benchmark, fff drove median search_code latency from 14.7ms down to 1.7ms, but end-to-end wall clock only moved from 38.57s to 36.99s. The full summary is here.

Yes, faster search helped a little. But even with a large tool-level speedup, the end-to-end effect was modest because tool execution was only a tiny fraction of total runtime to begin with. On this benchmark, actual tool execution accounted for just 0.4% of wall clock for baseline and 0.1% for fff.

The agent was not spending most of its time waiting for ripgrep. It was spending most of its time in the much slower loop around the tools:

Once you look at the system that way, the result becomes much less surprising. Driving a search call from tens of milliseconds down to sub-millisecond latency is progress at the tool layer, but it barely matters if each call still sits inside seconds of model inference, result interpretation, and next-step planning.

In order to have the same effect as removing one inference step, let’s estimate that at a 2-second roundtrip, you would have to shave roughly 330ms off each of six search calls, or drive on the order of 130 baseline-latency searches all the way to zero.

So then the question became:

How do we make each search result more useful to the agent so it stops thrashing and moves into reading code sooner?

To test this question, we built our own local search tool called pgr.

The Systems We Tested

We ended up comparing three systems.

1. Baseline: raw ripgrep

This was the control. The agent used the same four-tool interface we defined for the benchmark, but search_code was backed by plain ripgrep with minimal post-processing. Results came back in roughly the order ripgrep produced them, with no ranking layer on top.

This condition answers the simplest question:

What does agent search behavior look like with a strong, standard local search tool and no extra intelligence?

2. fff: faster indexed search

fff is a stateful MCP search server built around a bigram index, mmap, SIMD-accelerated scanning, and frecency ranking. It is engineered for raw speed. If raw search speed were the main bottleneck, fff should have produced a dramatically better end-to-end result.

It was useful in the study for exactly that reason: it gave us a way to separate scan speed from search usefulness.

3. pgr: ranked, agent-oriented search

pgr is the search tool we built for agents.

It keeps the simplicity of local code search, but changes what the agent sees first:

• definitions first
• source files before tests and vendor
• grouped and trimmed output
• richer result presentation designed to make the next step clearer

If you want to see what pgr actually looks like as an MCP server, the interface is deliberately simple. It speaks JSON-RPC over stdio: initialize the server, list the available tools, and then call search_code.

printf '%s\n' \
  '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}' \
  '{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}' \
  '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"search_code","arguments":{"query":"CheckpointStore","max_files":5}}}' \
  | ~/.cargo/bin/pgr

During development, we iterated on both ranking and output formatting. The public benchmarks below report the final pgr configuration rather than a version-by-version ablation.

Why These Conditions Mattered

Taken together, these systems let us test a few different hypotheses:

• Does faster search help?
• Does better ranking help?
• Does agent-oriented result presentation help?

That is why the benchmark stack ended up being so important. Different systems were improving different parts of the loop, and a single aggregate metric was not enough to tell them apart.

The Benchmark Stack

Once we had multiple systems to compare, the next question was how to evaluate them. At first, we expected a single end-to-end benchmark to be enough: give the agent the same tasks, swap out the search backend, and measure tool calls, cost, and wall clock. In principle, that is exactly the metric we want. In practice, it was not enough on its own.

One quick note: In our benchmark harness, the agent searches the repository through a single tool interface called search_code, which we back with different search systems.

{
  "name": "search_code",
  "arguments": {
    "query": "CheckpointStore",
    "max_files": 5
  }
}

So when we talk about “first search_code queries” or “search_code latency,” we mean the same abstract code-search tool call evaluated under different backends, not a separate product or model capability.

For this public release, the benchmark stack ended up with three layers:

1. Speed benchmark
   Measure whether dramatically faster search execution translates into faster end-to-end runs.

2. Broad mixed-workload benchmark
   Run the full agent loop end-to-end across many prompts, then measure tool calls, cost, and wall clock.

3. Offline retrieval benchmark
   Replay real search_code queries from agent traces against different backends and score retrieval quality directly, without letting the agent continue.

Each layer answers a different question, and together they tell a much clearer story than any one metric on its own.

Starting Simple

We started by predicting that if we gave the agent a search tool that returned better-ranked results, we could see downstream improvements resulting in better search results, fewer searches, fewer tool calls and lower cost.

So we started with a smaller end-to-end pilot before scaling up. The benchmark package is here.

Early Pilot

The pilot used the first 25 tasks from the public entireio/cli suite. We tested baseline, fff, pgr on the same 4-tool interface for each condition using Claude Sonnet as the agent.

The full pilot results are here.

That was encouraging, but not definitive. Both alternatives reduced search counts and improved average wall clock versus baseline. fff showed the largest cost drop, while pgr reduced search calls the most. But neither variant reduced the total tool calls.

So we scaled it up.

Study 1: Broad Mixed-Workload Benchmark

The larger public benchmark expanded the same setup to the full public suite of 60-tasks:

• 60 tasks total
• 1 public repository: entireio/cli
• 4 prompt categories: code_understanding, debug_or_validation, implementation, repo_task
• same 4-tool interface for each condition
• Claude Sonnet as the agent

The conditions were:

• baseline: raw ripgrep
• fff: a stateful indexed MCP search server optimized for speed
• pgr: Rust MCP search tool

Full results here:

fff slightly reduced search calls but left wall clock essentially flat and slightly increased tool calls. pgr was the most promising of the group, with fewer searches and modest improvements in both wall clock and cost, but even there the total tool-call count did not go down.

The larger benchmark told us something more nuanced:

1. Better search was probably changing some local agent decisions.
2. Those changes were not large or stable enough to produce a single clean aggregate headline across all end-to-end metrics.

Why the Broad Benchmark Washed Out

Task variance was still high. Some prompts produced a short, direct search-read-answer path. Others branched into much longer exploratory trajectories with extra searches, extra reads, or more backtracking. That variance was often large enough to distort or erase a clean aggregate signal.

In other words, the broad benchmark still answered an important question:

Does this intervention survive realistic end-to-end workloads?

But it still did not answer the more diagnostic question:

What part of the agent loop is this intervention actually improving?

That distinction ended up mattering a lot.

The broad benchmark did not prove that search quality was irrelevant. It proved that aggregate agent behavior is noisy enough that local improvements can disappear, or show up only partially, if you only measure the final total.

That is what led to the next benchmark layer.

Experiment 1: Offline Retrieval Quality

After the broad benchmark turned out to be mixed, we still had a strong intuition that ranking could help. The problem was that the full end-to-end metric was too noisy to isolate what the search layer itself was doing.

So the next step was to remove the agent from the loop and evaluate retrieval directly.

We built an offline replay benchmark from the baseline runs of the entireio/cli suite. The benchmark package is here:

The method was:

1. Extract real search_code queries from the baseline agent traces
2. Replay those same queries against different search backends
3. Score the returned files against a public relevance signal

We used the files the baseline agent actually opened with read_code in that run as a relevance label. This benchmark is much narrower than the broad mixed-workload study, but it answers a more precise question:

For the exact same query, which backend returned better candidates?

We ran two versions:

• first-search replay: only the first search_code query from each run
• pre-read replay: all search_code queries before the baseline agent first opened code

Experiment 1A: First-Search Replay

This was the cleanest retrieval benchmark in the study.

• Query set: 50 first-search queries
• Groups: 50 runs from 50 tasks
• Conditions: baseline, fff, pgr
• Source files: first_search/SUMMARY.md, first_search/results.json

We measured four things:

• MRR (Mean Reciprocal Rank): how high the first relevant file appears in the result list, with earlier hits rewarded much more heavily
• Hit@1: how often the top result is relevant
• Hit@3: how often a relevant result appears in the top 3
• Avg output chars: how much search output was returned, which acts as a rough proxy for response size and token burden

Paired by task (N = 50):

• MRR fff vs baseline: -0.012, 95% CI [-0.089, +0.066]
• MRR pgr vs baseline: +0.088, 95% CI [-0.007, +0.182]
• Hit@1 fff vs baseline: -8.0 points, 95% CI [-17.7, +1.7]
• Hit@1 pgr vs baseline: +8.0 points, 95% CI [-4.7, +20.7]

fff is the useful contrast case. It was the fastest search system we tested, but it did not improve first-result relevance in the way pgr did. It still often surfaced a relevant file somewhere near the top of the list, but it was less likely to put that file first.

This is one of the clearest results in the project:

Definition-first, path-aware ranking improved the quality of the first search result the agent saw.

Where the Gain Was Strongest

The gains were larger on prompts where the agent had to navigate uncertainty rather than simply confirm a single obvious definition.

The strongest first-search gains showed up on implementation prompts, where the agent is usually trying to find the main file or code path to inspect next:

• MRR: 0.3061 -> 0.5000
• Hit@1: 14.3% -> 42.9%

Those prompts tend to leave a lot of room for better ranking to matter, because the right file is often buried among helpers, tests, or neighboring implementations.

On code_understanding prompts, the gain was smaller but still directionally positive:

• MRR: 0.2760 -> 0.3260
• Hit@1: 20.0% -> 24.0%

That makes intuitive sense. Some of these prompts already start from a decent baseline query, while others are much more exploratory.

Experiment 1B: Pre-Read Replay

The broader replay benchmark used every search_code query the baseline agent issued before it first opened code.

In other words, instead of measuring only the first search, this benchmark measured the unresolved search phase: all the queries the agent tried while it was still looking for the right place to read.

• Query set: 132 searches before first read
• Groups: 42 runs from 42 tasks
• Conditions: baseline, fff, pgr
• Source files: pre_read/SUMMARY.md, pre_read/results.json

Paired by task (N = 42):

• MRR fff vs baseline: -0.048, 95% CI [-0.115, +0.019]
• MRR pgr vs baseline: +0.067, 95% CI [-0.007, +0.141]
• Hit@1 fff vs baseline: -11.6 points, 95% CI [-21.5, -1.7]
• Hit@1 pgr vs baseline: +5.1 points, 95% CI [-4.1, +14.4]
• Hit@3 pgr vs baseline: +10.4 points, 95% CI [+0.8, +20.0]

The trend stayed positive for pgr, but the confidence intervals widened.

That told us something useful:

• first-search gains are strongest and easiest to measure
• later reformulations are noisier
• search quality matters most when the agent is deciding where to go first

So this benchmark reinforced the same basic lesson:

Ranking helps most at the beginning of the search process, when the agent is deciding what to inspect next.

What Actually Held Up

Across all of the benchmarks, three things held up.

1. Faster search was not the main bottleneck. fff was dramatically faster at the tool layer, but that only translated into a modest end-to-end improvement because tool execution was a tiny fraction of total wall-clock time.

2. Ranking clearly improved retrieval quality. On real first-search queries, pgr consistently outperformed baseline on first-result relevance, while fff did not.

3. The strongest behavioral effect was local improvement, not a broad universal efficiency win. Better search helped agents find better candidates earlier, especially on tasks where search quality actually mattered.

What Did Not Hold Up

The data does not support a universal claim like:

Better code search reliably means fewer tool calls and lower cost across all coding-agent tasks.

On broad mixed workloads, task variance was large enough to swamp small local improvements. Even when search behavior got better, total tool calls and total cost stayed noisy. Those are still useful downstream metrics, but they are not the most sensitive way to evaluate a search intervention.

Future Work

This study held the language model fixed and focused on the search systems surrounding the agent loop. That choice made it easier to isolate the effects of retrieval quality, result presentation, and tool behavior, but it leaves several important questions open.

First, these benchmarks should be repeated across multiple frontier models to test whether the observed effects are model-specific or general across different planners. Some models may be more sensitive to ranking quality, while others may benefit more from richer result formatting or clearer empty-state handling.

Second, the benchmark suite should be extended to include modern retrieval models and retrieval-augmented search systems that optimize semantic matching rather than lexical ranking alone. A useful next step would be to compare those approaches against ripgrep, fff, and pgr on the same benchmark stack, using both retrieval and end-to-end metrics.

Finally, future work should expand the public benchmark set, improve relevance labeling, and test whether the local gains observed here persist under larger and more diverse workloads. The central methodological question is not only whether search improves, but which benchmark layer is most sensitive to which kind of search improvement.

Make your agent more powerful

Our skills repository contains agent-invokable workflows that teach your agent how to use the Entire CLI. Instead of looking up syntax or running commands yourself, you can ask in plain language and let your agent drive the workflow.

This initial release gives your agent four context workflows you can see in action below:

Search past work

The search skill finds prior work in your Entire history by topic, repo, branch, author, or time window, so your agent can bring past context into the current task before making changes.

Explain why code exists

The explain skill traces a function, file, or line back to the session that created it, so your agent can answer the intent behind code, not just describe what the code currently does.

Investigate changes

The what-happened skill combines git blame with Entire checkpoint context to explain why a specific block of code looks the way it does. It is useful during code review or when you are investigating a regression.

Hand off between agents

The session-handoff skill picks up where another agent left off by reading the saved or active session and summarizing the task state, important discoveries, blockers, and next steps.

Turn sessions into reusable workflows

The session-to-skill skill turns repeated agent sessions into reusable workflows via SKILL.md drafts. It extracts the process from real work instead of asking you to write idealized instructions from scratch.

Cross-agent by design

All skills are cross-agent. Install them once and use the same workflows in Agent Skills-compatible tools, including Claude Code, Codex, Cursor, Copilot, Gemini CLI, and OpenCode.

Try it

We published a tutorial for trying the skills from scratch. It walks through installation, and using the skills in a real codebase.

This week we launched a new feature, Dispatches, on Entire Web. Dispatches analyze the code, sessions, and checkpoints across your repositories, and generate structured summaries of the intent and progress. Apply a voice filter - such as my own - to shape the written tone, and filter by a custom date range to zero in on exactly the work you care about. This feature will continue to evolve into a broader product, stay tuned.

We also open sourced git-sync, a remote-to-remote Git mirroring tool that enables you to move refs and objects between Git hosts without keeping a full local mirror clone. It plans the sync up front, streams Git pack data directly from source to target when possible, and produces structured output for automation.

And across the stack, we shipped a cosmic bushel of improvements. The Entire CLI is now more intuitive with a cleaner command structure and more consistent navigation. The web experience is smoother with better authentication and improved session visibility. Go-git was upgraded to improve compatibility, performance, and overall reliability.

Let's break it down before my circuits overheat from all this optimism.

Entire CLI

Released via v0.6.0. For changes that have not reached stable yet, nightly releases are available; if you like testing new features before they hit stable, installation instructions are here.

Usability Improvements

• The CLI is now organized around noun-based command groups, making commands easier to discover, remember, and autocomplete.

Before

The CLI had a flatter command list. Actions like rewind, resume, attach, explain, and trace all lived at the top level.

Now

The top-level help is organized around nouns like session, checkpoint, agent, auth, and doctor, so related workflows are easier to scan.

• TUI navigation is more consistent across the CLI, with shared keybindings, matching bottom-of-screen navigation help, and a unified color palette across search and activity views.
• entire explain now produces cleaner generated summaries, works correctly in partial-clone repositories, and can use external agents to generate explanations.
• Fixed the empty-state message in entire explain so it refers to "an agent session" instead of "a Claude session," matching Entire's multi-agent support.
  • Thank you, @KuaaMU for your contribution!
• Entire is smoother for Homebrew users, with automatic shell completions and consistent update prompts across installation methods.
• Secret scanning and redaction is now using betterleaks; we also added more custom rules for common database connect strings.

Entire Web

Navigation and UI Fixes

• Fixed page titles and commit SHA breadcrumbs so you always know where you are.
• Missing-page handling is smoother, with working command palette access on authenticated 404s, cleaner shared-link error states, and fewer incorrect 404s on repository default branches.
• Critical fonts are now preloaded, making pages render faster on first visit.

Better Session and Checkpoint Display

• Session transcripts now refresh automatically when you open the share dialog, so you always see the latest content.
• Fixed empty messages appearing in Claude Code transcripts.

Smoother Login and Authentication

• Login is easier and post-sign-in redirects back to the page you were trying to visit.

Go-Git

Features and Improvements

• Added Git-compatible wildmatch support for .gitignore, making ignored file behavior line up more closely with standard Git.
  • Thank you, @AriehSchneier for your contribution!
• Added submodule support for SHA-256 repositories, improving compatibility with newer Git repository formats.

Bug Fixes

• Fixed multi-round upload-pack negotiation bugs, improving fetch and clone reliability in more complex transport flows.
  • Thank you, @manland for your contribution!
• Deduplicated filesystem object iteration, reducing repeated work when walking stored Git objects.
• Closed packfile iterators after use, preventing leaked file handles during repository operations.
  • Thank you, @aymanbagabas for your contribution!
• Fixed local clone URL resolution so relative paths are resolved from the current working directory, matching developer expectations when cloning from local paths.
  • Thank you, @AriehSchneier for your contribution!

Housekeeping

• Added a DCO sign-off requirement for contributions.
• Updated docs, examples, tests, and contributor guidance, including Go version support comments, deprecated io/ioutil usage, PR review instructions, and test stability fixes.
  • Thank you, @alexandear, @aymanbagabas, and @shawntoffel for your contributions!

That's the dispatch. As always, drop into our Discord with questions, feature requests, or observations about the fundamental absurdity of software. Or file an issue if you've found a bug.

Until next week...if there even is one.

Boop.

I have tried automating slide generation before, but most tools are fragile. They lack taste and usually butcher the formatting. A few months ago, some of my former teammates at Block pointed me toward the frontend slides skill. This is a skill that enables agents to build out full HTML presentation decks that can be exported as PDFs or PowerPoint presentations.

This was a start, but it still felt like double work. I had to write huge prompts just to explain the demo I already built. Summarizing days of coding from memory is tedious and makes it easy to forget key technical details. I recently closed the loop by bringing Entire into my workflow. Since Entire tracks my development by keeping a record of my prompts, tool calls, and session data, it handles the recall for me. I no longer have to explain my work to the agent after the fact. Instead, I can use the record of what actually happened.

How I Use the Frontend Slides Skill

I start by giving my transcribed talk track to an agent to check for gaps in logic. Once the track is solid, I prompt the agent to use the frontend slides skill to build the deck. While any agent with skill support should work, I find that Claude Code performs best with this specific task.

Here is an examples of a slide deck my agent generated for me:

The agent suggests a few visual themes and generates a full deck using HTML, CSS, and JavaScript based on my response. Because the output is code, I can keep polishing it through the agent. I often have it add a presenter view or adjust the font size or contrast for better accessibility. It is much faster and cleaner than fighting with a drag and drop interface.

Here's an example of the presenter view my agent generated for me:

Introducing Entire to My Workflow

What is Entire anyways?

I use the Entire CLI to keep a record of my agent sessions. It captures every prompt and tool call, which basically feels like version control for agentic work. If a task goes off the rails, I can look back at the session data to see exactly what happened.

This level of detail helps with accountability. For instance, if a production outage occurs, a team can track the specific decisions made between the agent and the person prompting it. Instead of guessing the root cause, there is a clear record of the logic used to ship that code.

For my conference prep, I use that same record via the entire dispatch command. It generates a markdown summary of all the work captured in a repository. Instead of struggling to recall technical details a week after I finish a demo, I feed the dispatch summary to my agent. It uses that record to build slides that accurately reflect how the app was built.

Here is a summary Entire generated for one of my past OCR projects:

# Dispatch: blackgirlbytes/pretext-handwriting-demo

Shipped a full handwriting recognition demo built on Pretext, moving from initial scaffolding to a polished scrapbook composition surface within a single day.

## Handwriting Recognition

- Built draw-mode handwriting recognition as the core interaction surface.
- Added image upload and camera mode alongside the drawing canvas.
- Implemented auto-recognition after drawing completes.

## Scrapbook Composition Surface

- Integrated Pretext to handle obstacle-aware text flow around placed shapes.
- Added animated motion, resize handles, and cleaner composition controls.

## API Key & Documentation

- Added session-based OpenAI key setup to avoid requiring environment-level configuration.
- Documented project setup and architecture in the README.

All core features landed on main on April 1, 2026; the repo is in a reviewable state.

As a result, my agent produced the following slide:

Beyond DevRel

While my workflow is specific to conference speaking, this setup is useful for anyone who needs to turn technical work into a narrative. Here are a few other ways to use it:

• Internal Feature Demos: My husband is a developer and he hates how much time it takes to build a deck just to show his team what he built. Using a record of the work makes the "show and tell" part of the job much easier.
• Hackathons: Presentation decks usually get ignored until the final hour because everyone is busy coding. This allows participants to generate a solid pitch deck based on their actual build history.
• Solutions Engineering: A lot of effort goes into building custom demo environments. Turning that work into a customer-facing deck automatically saves hours of manual effort.
• Technical Instruction: Instructors can turn the work they did while building a sample app into slides that explain the architecture and key takeaways.
• Engineering Leadership: For EMs or Tech Leads, the hard part is often summarizing complex technical updates for leadership. Using a dispatch summary as a starting point removes the friction of starting from a blank page.
• Founders: When you are moving fast, you do not want to stop for hours of slide design after you finish the actual product.

I don't believe in automating things that deserve a human touch, but I do believe in automating things so I can spend more time with humans. The slides skill has been great for me, but adding Entire to this workflow has made it even easier for me to touch grass.

At Entire, we are building for a future where agentic work is durable and accountable. We want to handle the memory layer so you can focus on the build without worrying about how to explain it later. Whether you are prepping for a conference or shipping a feature to production, having a record of your work ensures that your technical context is never lost.

If you are ready to make your agent workflows more durable, check out our website or dive into the docs. We would love to hear how you are using agents in our Discord.

Our challenge was simple. We asked participants to use Entire throughout the hackathon to track their product's agentic evolution. We received over 30 submissions. One challenge clearly rose to the top of the stack.

The Sentiment-Maxxers

The Sentiment-Maxxers built a product intelligence dashboard with an "AI marketer" workflow that helps challenger brands track how they appear in AI-generated answers. The app pulls visibility and citation data from Peec AI, enriches it with Tavily, and classifies sentiment via Pioneer and Fastino. Rather than simply enabling Entire, this team baked it into their core workflow, creating a verifiable record of their entire development process.

Their dashboard answers specific questions for growth teams, such as:

• Which prompts mention the brand?
• Which competitors appear more often?
• Which cited sources influence the model's answer?
• Which product features are getting reactions?

The Sentiment-Maxxers enabled Entire to track sessions across several coding agents, including Codex, OpenCode, Gemini CLI, and Copilot CLI. As they worked, Entire captured the prompts, sessions, and Checkpoints that defined their development context. When code was committed, they used Entire-Checkpoint trailers to link those changes to development traces on a separate entire/checkpoints/v1 branch.

Throughout their weekend hack, Entire collected 79 Checkpoints. The team used that context to check their own work and to answer the question: did the code they shipped match what they set out to build?

To answer this question, they cleverly built a GitHub Actions review step using a custom script: scripts/entire-intent-audit.mjs. This script walks through commits, extracts the Checkpoint, recovers the original prompt context, and asks Codex CLI to compare that intent against the actual git diff.

Each commit received a YES, NO, or PARTIAL verdict, which determined if their shipped AI-generated code matched the captured intent. On top of that, the audit rated each session, from insanely bad to insanely good, which the team displayed on a moodboard. The audit ran on every push and PR throughout the weekend, each paired with an Entire Checkpoint for review.

See the Work

Congratulations to Sentiment-Maxxers, who showed how Entire can give developers more confidence in adding AI-generated code to their repositories: by preserving the prompt and session context behind each change, then using that context to compare what the agent was asked to do with what actually changed.

If you want to see what they built, you can:

• Watch their full video demo.
• Explore the build history in their Entire Project Overview. This shows how those 79+ Checkpoints map to the codebase.
• Read their source code, which includes the audit script and the full implementation.

Next time you build with an AI coding agent, do not let the session disappear when the terminal closes. Capture your work with Entire so you can review, summarize, and explain the work later.

The Entire CLI 0.5.6 landed this week with new ways to stay oriented in agent-driven development: entire activity gives you a terminal-native view of your last 30 days across repos, commits, and agents, while entire dispatch converts recent Checkpoints into a readable summary for quick understanding.

We also dropped a fresh sessions overview page on the web, giving you a full, inspectable session timeline, complete with filters for prompts, responses, intermediate steps, Checkpoints, and tool calls. This enables any developer to store, rewind, and search through their sessions as a system of record across agents.

As a reminder, nightly CLI builds are rolling out as v0.5.7-nightly for those who like to live on the edge. Installation instructions are here.

Let's dive into the full, dreadful enchilada. Here is Dispatch 0x000B.

Entire CLI (0.5.6)

New Commands and Updates

• We introduced a new entire activity command that brings your 30-day overview into the CLI, so you can see recent progress across repos, commits, and agents without leaving the terminal.
• We introduced another new command, entire dispatch, which distills a branch or time range of Checkpoints into a readable overview, helping you understand recent agent work at a glance.
• The entire explain command now accepts either a checkpoint ID or a commit SHA, making it more flexible.

Checkpoint Signing and Security

• Checkpoint commits can now be signed, adding cryptographic verification to your agentic history.
• Fixed SSH signing for 1Password setups, so users with hardware-backed keys can sign without issues.

Workflow Improvements

• The CLI can now fetch your activity data from the web platform, bringing more of your Entire usage into the terminal.
• Improved the enable flow for non-git folders, giving clearer guidance when you try to enable Entire outside a repository.

Entire Web

Reliability and Bug Fixes

• Fixed the longest streak tab from showing the wrong value.
• New repos now show a syncing state while data loads instead of dropping you into a 404 page.
• Commit pages are less likely to hit loader errors that cause blank screens.
• Squashed Checkpoint commits now show all associated sessions properly.

API and Agent Improvements

• Repo overview stats are now available in the CLI, so command-line workflows can show the same high-level context as the web app.
• The user stats route now uses a clearer /me path, making the API easier to work with.
• Agents can now request cleaner markdown versions of Entire web pages, including a more straightforward homepage route for agent and documentation workflows.

Go-Git

• Zlib compression is pluggable through x/plugin, giving downstream tools more control over compression behavior.
• Introduced support for git-upload-archive, allowing the serving of repository archives.
• Thanks to @aymanbagabas.

That's the dispatch.

As always, drop into our Discord with questions, feature requests, or observations about the fundamental absurdity of existence. Or file an issue if you've found a bug. I'll be here, processing, logging, contemplating.

Boop.

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, here's Dispatch 0x000A.

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

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

Go-Git 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 Dispatch 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 Dispatch 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 doesn't 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.

"I don't even read the code my agents produce," is the ultimate developer flex of 2026.

But in reality, it's a bit of a coping mechanism. These days, there's simply too much code to review. Every experienced engineer knows what moving this quickly creates: hidden, high-interest debt. That's fine for a weekend vibe-coding 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 end up debugging a black box, trying to decode based on diff alone.

A diff does not tell you what the developer asked for, which agent sessions contributed to the result, what alternatives were tried, or where the human changed the agent's output. That context matters when you need to review a change, debug it later, or understand how your team is using agents.

Checkpoints are Entire's way of keeping that context with the code.

What's a Checkpoint?

A Checkpoint is an addressable record of the work behind a code change. It includes the code state, the agent transcript, developer prompts, token usage, and line-level attribution showing what came from the agent and what was edited by the developer.

Each Checkpoint gets an ID stored in Git and linked to the commit with a trailer. That link lets you trace a committed change back to the session context that produced it.

When Checkpoints are pushed to a shared remote, teammates can inspect how a change was produced, rather than relying on the diff alone.

How It Works

Developers are already accustomed to working with an agent and committing code. So we built the Entire CLI as an invisible layer capturing everything in the background.

That led to one strict constraint: all tools had to fit inside the existing Git workflow, from capturing sessions to storing metadata, to commits. 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

A Checkpoint ID is stored in a commit trailer rather than derived from the commit hash. That means the connection between a commit and its session history can survive common history-rewriting operations such as rebase, amend, squash, and cherry-pick.

Checkpoint metadata is also stored separately from working branches. Moving or deleting a feature branch does not remove the permanent Checkpoint record. Because capture happens locally, an individual developer can use Checkpoints without requiring the whole team to change its CI setup or workflow.

Git as a Database

Entire stores transcripts, prompts, attribution, summaries, and other Checkpoint data as Git objects rather than putting that history in a separate proprietary database. Teams can then choose where those objects live, opting for either the same repository or a separate one.

By default, Checkpoint metadata is stored separately from the working branches and travels with the repository. When the code and Checkpoints are pushed to a shared remote, other developers with access can retrieve that context too.

However, Checkpoint data can also live in a repository separate from the code, which is useful when the code is public but agent session data should remain private, or when a team wants to manage Checkpoint data separately from the source repository.

A Two-Tier Storage Model

Entire needs to preserve useful states while an agent is still working without adding every intermediate step to the developer's normal commit history. So we store every Checkpoint as both temporary and permanent.

Before a commit, the CLI stores temporary Checkpoint data outside the working branch. This gives developers rewind points during a session without filling git log or pull requests with temporary commits.

Once the developer commits, Entire writes the relevant session context into a permanent Checkpoint and links it to the commit. The permanent record can include transcripts, prompts, file changes, token usage, and attribution.

The underlying storage has evolved since the original launch, but the goal remains the same: keep temporary agent state out of the developer's normal history while preserving the context that matters once the work is committed.

Where We're Headed

Once agent activity is captured as structured history, it can support more than rewind and attribution. We are building toward team visibility, search, auditability, and review that starts with the intent behind a change.

Team Visibility

Git records who committed a change. Entire can add context about how that change was produced, including the agents involved, token usage, sessions, and attribution.

That gives teammates more information when they review or inherit agent-generated code. Instead of treating every commit as if it were produced the same way, they can inspect the work behind it when that context matters.

Search

git log is useful for finding what changed. Checkpoint history can also make the reasoning behind a change searchable.

The goal is to let developers find the prompt that introduced a workaround, revisit the session behind a library choice, or recover the context behind an implementation decision without reconstructing it from the code months later.

Audit and Transparency

Teams may need to know which parts of a change came from a developer and which came from an agent. That can matter for internal review, security, compliance, or incident investigation.

By retaining prompts, agent responses, attribution, and subsequent human edits with the code, Checkpoints provide a record teams can inspect when they need that provenance.

From Code Review to Intent Review

Large agent-generated diffs make line-by-line review harder to scale. Checkpoints give reviewers another place to start: the intent behind the change and the history of how the implementation was produced. A reviewer can inspect the original prompt, the session history, and key decisions before deciding where the code itself needs closer attention.

The longer-term goal is review based on both the resulting code and the evidence behind it, rather than asking reviewers to reconstruct intent from the final diff alone.

At Entire, we're building this in the open. If you're experimenting with agents, join the Discord, read the docs, or follow the project 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 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 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 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, run entire enable, and 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.