<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/">
  <channel>
    <title>Entire Blog</title>
    <link>https://entire.com/blog</link>
    <description>News, updates, and stories from the Entire team.</description>
    <language>en</language>
    <lastBuildDate>Tue, 17 Nov 2026 00:00:00 GMT</lastBuildDate>
    <atom:link href="https://entire.com/feed.xml" rel="self" type="application/rss+xml"/>
    <atom:icon>https://entire.com/images/rss-icon.png</atom:icon>
    <image>
      <url>https://entire.com/images/rss-icon.png</url>
      <title>Entire Blog</title>
      <link>https://entire.com/blog</link>
    </image>
    <generator>Entire</generator>
    <item>
      <title>Here’s How Entire Stores Your Code In-Region</title>
      <link>https://entire.com/blog/heres-how-entire-stores-your-code-in-region</link>
      <description>Hint: It’s not through content delivery networks (CDNs), read replicas, or AWS regions.</description>
      <pubDate>Tue, 17 Nov 2026 00:00:00 GMT</pubDate>
      <category>Engineering</category>
      <dc:creator>Joseph Katsioloudes</dc:creator>
      <content:encoded><![CDATA[<p>The word "region" can mean different things to various developers based on their backgrounds. For those more familiar with cloud and AWS, it can mean an isolated deployment with its own blast radius. To those with a web background, it can mean an edge cache with a TTL, and for those who run databases, it may be a standby trailing a primary. These are reasonable interpretations of the word, but none are correct when it comes to what we shipped last month in Singapore, Brazil, and the UK, in addition to existing regions in the US, Europe, India, and Australia.</p>
<h2>What Is a Region?</h2>
<p>A region is built from one or more cells, with each cell hosting a complete copy of your Git repository. Clones and pulls use the regional copy your remote points to, or the closest one if you clone with <code>--nearest</code> (e.g. <code>entire repo clone /gh/entireio/cli --nearest</code>). Pushes route through the repository's home cell, in the region you chose to host it upon creation. Nothing here is a cache, but a deliberate design choice of a distributed architecture from day one that you can learn more about in our CTO’s blog post, <a href="/blog/a-git-forge-without-a-center">A Git Forge Without A Center</a>.</p>
<p>With this architecture in place, your repo can live in multiple regions, and if it lives on GitHub, then GitHub remains the source of truth. Then, when you mirror to Entire, regions will serve clones and pulls from the copy nearest to your agents. On the write path, Entire is the fastest Git forge in production today, sustaining 418 pushes per second, up to 89x faster than GitHub and 6x faster than Cursor Origin in our <a href="https://github.com/entireio/forgemark">open-source benchmarks</a>. You can mirror from GitHub to Entire using our <a href="https://docs.entire.com/guides/repositories/mirrors">documentation</a>.</p>
<h2>Why Is a Region Not a CDN?</h2>
<p>Content Delivery Networks (CDNs) are meant to solve a narrow problem: content that is written once and will be read millions of times by users without writing something back. Think of Netflix or npm.</p>
<p>Your repository is actually the opposite. It takes writes all day from you and agents, with infrequent reads.</p>
<p>A <code>git fetch</code> is not a file download because there are client-server negotiations taking place between haves against wants, as part of the Git protocol. A cache serves finished artifacts, and it expires. A stale cache of a film is a rerun. A stale cache of a repo is a bug.</p>
<p>The biggest difference is that a cache cannot deliver uncached artifacts when its origin is down while an Entire region holds every byte of your repository, so it keeps serving when the origin does not.</p>
<h2>So Is It a Read Replica?</h2>
<p>A read replica is slightly closer in architecture to an Entire region because reads are local everywhere. For example: when you clone, fetch, and pull from Singapore, changes will hit Singapore. On the other hand, writes are anchored, as every repository has a home cell that is the region where it was created, and pushes through any other region are forwarded there.</p>
<p>When mirroring your repository, GitHub is that primary. So pulls never leave your region, while a push from Australia to a US-homed repository crosses the Pacific first. Between cells, replication is asynchronous.</p>
<p>So on the write path, yes, a region behaves much like a read replica: reads are local, writes go to one home cell. What matters for agents is that each region holds the complete repository, so clones and pulls keep working when the home region or GitHub is unreachable. Agents read far more than they write, so most of their work continues.</p>
<h2>Do Entire Regions Fail in Isolation like AWS Regions?</h2>
<p>Yes, they do. An Entire region fails in isolation the same way an AWS region does: the failure stays contained, and the other regions keep serving. The difference is what sits inside the isolation boundary. In AWS, each region holds only what you deployed there, so surviving a regional failure is an architecture you design, with cross-region replication as your homework. On Entire, every region that hosts your repository holds the complete copy by default. A region can fail on its own; every other placement of your repository keeps serving.</p>
<h2>Create Your First Repository on Entire Today</h2>
<p>The fastest way to learn about Entire regions is to create a repository in one yourself by following our <a href="https://docs.entire.com/guides/repositories/repository">documentation</a> or this YouTube <a href="https://www.youtube.com/watch?v=JJaLBDHPD-0">walkthrough</a>. Then let us know what you thought by joining our <a href="https://discord.gg/jZJs3Tue4S">Discord community</a>.</p>
<p>Happy building!</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/heres-how-entire-stores-your-code-in-region</guid>
    </item>
    <item>
      <title>Your Agents Can Now Sign In as Themselves</title>
      <link>https://entire.com/blog/your-agents-can-now-sign-in-as-themselves</link>
      <description>Service accounts give CI jobs, cloud functions, and agents their own scoped access to Entire repositories, no human login required.</description>
      <pubDate>Fri, 13 Nov 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Haimantika Mitra</dc:creator>
      <content:encoded><![CDATA[<p>Today, we are introducing service accounts on Entire. Service accounts are designated logins for each CI job, cloud function, or agent you work with on Entire, with only the scoped access you laid out.</p>
<p>A service account belongs to one project and gets one of the same roles you’d give to people: <code>reader</code>, <code>writer</code>, or <code>admin</code>, on repositories you select in the project. As a best practice, grant the narrowest role that allows them to function as needed. A service account can't reach repositories in other projects, so even a leaky deploy script’s impact is restricted.</p>
<p>If your code runs on a platform that issues OpenID Connect (OIDC) tokens, like GitHub Actions or Cursor, you can bind that platform to the service account once. Every job or agent then signs in with its own short-lived token. This process prevents secret leaks and keeps you from having to store or rotate secrets. Everywhere else, you create a service account secret that lasts 90 days by default, and the Entire CLI, Git remote, and Go SDK handle the token exchange for you.</p>
<p>Each organization or account is granted up to five service accounts across its projects. Service accounts work in projects hosted on Entire, which means that you should <a href="https://docs.entire.com/guides/repositories/repository">host your repositories on Entire</a> if you haven't already. Here's how to get started:</p>
<h2>Create a Service Account on Entire</h2>
<ol>
<li>
<p>On <a href="https://entire.com">Entire</a>, open your project, go to <strong>Settings</strong>, and select <strong>Service accounts</strong>.</p>
</li>
<li>
<p>Select <strong>Create service account</strong>, give it a name like <code>deploy</code>, and select <strong>Create</strong>. The dialog shows the service account's ID and Auth URL, which your agents use to sign in.</p>
<p><img src="/blog/your-agents-can-now-sign-in-as-themselves/create-service-account.jpg" alt="The Service account created dialog on Entire, showing the new service account&#x27;s ID and Auth URL with copy buttons"></p>
</li>
<li>
<p>Next, open the service account and, under <strong>Repository access</strong>, select <strong>Add repository access</strong>.</p>
</li>
<li>
<p>Pick a repository and a role, then select <strong>Add</strong>. (To grant access to every repository in the project at once, use the CLI.)</p>
<p><img src="/blog/your-agents-can-now-sign-in-as-themselves/add-repository-access.jpg" alt="The Add repository access dialog for the deploy service account, with the web repository selected and the Reader role chosen"></p>
</li>
<li>
<p>To let GitHub Actions sign in without a secret, go to <strong>Bindings</strong>, select <strong>Add binding</strong>, and choose the provider. Each field is a pin (a value the job's token must match), such as your repository name.</p>
</li>
<li>
<p>You can also lock it to a branch by selecting <strong>Add condition</strong>. For GitHub Actions, the page then hands you the exact workflow step to paste in.</p>
<p><img src="/blog/your-agents-can-now-sign-in-as-themselves/add-binding.jpg" alt="The Add binding dialog with GitHub Actions as the provider, acme/web as the repository pin, and an Add condition option"></p>
</li>
</ol>
<h2>Set It Up from the CLI</h2>
<p>From the terminal, you need to use the command <code>entire service-account</code>, or its alias <code>entire sa</code>. For example, you can create a service account called <code>nightshift</code> in the <code>rebellion</code> project, with write access to a repo called <code>hangar</code>, signing in from GitHub Actions. To do so, you’d need to use the below commands:</p>
<ol>
<li>
<p>Create the service account:</p>
<pre><code class="language-bash">entire service-account create rebellion nightshift
</code></pre>
</li>
<li>
<p>Give it access to one repository (or use <code>--project</code> for all of them):</p>
<pre><code class="language-bash">entire service-account grant rebellion/nightshift --repo hangar --role writer
</code></pre>
</li>
<li>
<p>Bind GitHub Actions so its jobs sign in with no secret at all:</p>
<pre><code class="language-bash">entire service-account bind rebellion/nightshift --provider github-actions --pin repository=rebellion/hangar
</code></pre>
</li>
</ol>
<p>If you are running somewhere without OIDC, you can create a secret instead. It prints once, so send it straight to a secure file or your secret store:</p>
<pre><code class="language-bash">entire service-account secret create rebellion/nightshift > nightshift.secret
export ENTIRE_TOKEN="$(cat nightshift.secret)"
entire repo clone /et/rebellion/hangar
</code></pre>
<p>Secrets last 90 days by default, or anywhere from 1 to 365 days with <code>--expires-in-days</code>. Each service account can hold two unexpired secrets, so you can roll a new one before retiring the old. Read about all this and more, including raw token exchange for any HTTP client, in our <a href="https://docs.entire.com/guides/configuration/service-accounts">docs</a>.</p>
<h2>Join the Rebellion</h2>
<p>More coming soon, so watch this space. Now, if you'll excuse me, I have a few personal access tokens to go revoke. As always, bring questions, bugs, and jokes to <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a>.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/your-agents-can-now-sign-in-as-themselves</guid>
    </item>
    <item>
      <title>Tips and Tricks with Trails: How to Apply Path Filters</title>
      <link>https://entire.com/blog/tips-and-tricks-with-trails-how-to-apply-path-filters</link>
      <description>To control when an Entire review agent runs automatically, add a paths list of glob patterns to the agent’s push trigger.</description>
      <pubDate>Wed, 11 Nov 2026 00:00:00 GMT</pubDate>
      <category>Community</category>
      <dc:creator>Lizzie Siegle</dc:creator>
      <content:encoded><![CDATA[<p>A <a href="https://docs.entire.com/guides/trails/overview">Trail</a> is Entire's alternative to the pull request. It puts confidence evals and coding sessions at the center of review, alongside all the context that created a diff. You can start a Trail before writing any code by asking your agent, running a terminal command, or using the web UI.</p>
<p>To customize your confidence evals, configure review agents to evaluate the changes in a Trail against instructions you set. For example, one review agent might check migration risk and another might check frontend code quality. Each returns findings or an evaluation score. When you push updates, review agents with matching triggers review the change again, and you follow their results on the Trail to decide whether the change is ready to merge.</p>
<p>In a monorepo, each review agent usually covers a different part of the codebase. Without path filters, fixing a one-line docs typo can trigger both your frontend reviewer and your migrations agent, as long as the change meets their other trigger conditions. When Entire has the complete file list, path filters skip those runs if no files in the current diff match the agent’s patterns.</p>
<p></p>
<p>This video shows how to open an agent’s configuration, add a pattern under <strong>Only when these paths change</strong>, and save it.</p>
<h2>How Do I Filter an Entire Agent’s Runs by File Path?</h2>
<p>Add a <code>paths</code> list of globs to your agent’s push trigger. With a complete changed-file list, the path filter matches when the current diff includes at least one file that matches a listed pattern.</p>
<p>We use this in our own repos. One of our frontend reviewer’s push triggers includes:</p>
<pre><code class="language-yaml">paths: ["frontend/**"]
</code></pre>
<p>A change confined to <code>backend/</code> won’t match this filter, but a change that includes files in <code>frontend/</code> will. Skipping those unrelated reviews saves runner time and cuts irrelevant verdicts.</p>
<p>Entire checks <a href="https://docs.entire.com/guides/trails/agents">the full change from merge base to head</a>. A later push that only changes docs still matches if an earlier frontend edit remains in the current diff. If that edit is fully reverted, it no longer counts as a match.</p>
<p>Select paths that match each agent’s scope:</p>
<table>
<thead>
<tr>
<th>Agent</th>
<th><code>paths</code></th>
</tr>
</thead>
<tbody>
<tr>
<td>Frontend reviewer</td>
<td><code>["frontend/**"]</code></td>
</tr>
<tr>
<td>Migrations agent</td>
<td><code>["db/**", "migrations/**"]</code></td>
</tr>
<tr>
<td>API agent</td>
<td><code>["services/api/**"]</code></td>
</tr>
</tbody>
</table>
<p>Patterns within <code>paths</code> combine with OR: a match on any one pattern is enough, so the migrations agent’s filter matches files in either <code>db/</code> or <code>migrations/</code>.</p>
<h2>Can I Combine Path and Branch Filters?</h2>
<p>Yes! Push triggers also accept a <code>branches</code> glob list. To review frontend changes on release branches, you can combine the filters:</p>
<pre><code class="language-yaml">paths: ["frontend/**"]
branches: ["release/*"]
</code></pre>
<p>Different filters combine with AND. With a complete changed-file list, the branch must match <code>release/*</code>, and the full change must include a file that matches <code>frontend/**</code>.</p>
<p>The trigger's readiness condition still applies on top of both filters.</p>
<h2>FAQ</h2>
<h3>Does a path filter check only my latest push?</h3>
<p>No. Entire checks the current diff from merge base to head, not just the latest push. A docs-only push still matches if an earlier edit to a filtered path remains in that diff. If that edit is fully reverted, it no longer counts as a match.</p>
<h3>How many patterns need to match?</h3>
<p>Just one! Patterns within <code>paths</code> combine with OR, so any single match satisfies the path filter. The branch filter and readiness condition still apply.</p>
<h3>How do path and branch filters work together?</h3>
<p>They combine with AND. With a complete changed-file list, the branch must match a <code>branches</code> pattern and the change must include a file that matches a <code>paths</code> pattern.</p>
<h3>What happens if a review agent has no path filter?</h3>
<p>Without a path filter, a review agent runs on every open change in its selected repos, as long as the change still meets its branch filter and readiness condition.</p>
<h3>Can I exclude paths, like <code>!docs/**</code>?</h3>
<p>No, negated patterns are not supported.</p>
<h3>What glob syntax is supported?</h3>
<p>Path patterns are repo-relative: <code>*</code> matches within one folder and <code>**</code> across folders, so <code>frontend/**</code> matches anything under <code>frontend/</code> and <code>**/*.go</code> matches every Go file.</p>
<h3>What if the changed-file list is incomplete?</h3>
<p>If the changed-file list is incomplete, the path filter allows the run even when none of the known files match. The branch filter and readiness condition still apply.</p>
<h3>Do path filters apply to manual runs?</h3>
<p>No, manual runs ignore both branch and path filters. Path filters only control when an agent runs automatically, such as on a push. To define what the agent reviews, use its instructions.</p>
<h2>What’s Next?</h2>
<p>Start with your busiest agent and take a peek at the changes behind some of its recent runs. If it keeps running on unrelated changes, add a path filter. When you create your next specialized reviewer, choose its paths while you’re writing its instructions. Let us know what you’re building or your thoughts on <a href="https://discord.gg/jZJs3Tue4S">Discord</a>!</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/tips-and-tricks-with-trails-how-to-apply-path-filters</guid>
    </item>
    <item>
      <title>Secure Your Repositories with Reference State Logs</title>
      <link>https://entire.com/blog/secure-your-repositories-with-reference-state-logs</link>
      <description>Entire is the first Git forge to offer a cryptographically verifiable history of Git reference changes, stored directly in your repository.</description>
      <pubDate>Tue, 10 Nov 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Paulo Gomes</dc:creator>
      <content:encoded><![CDATA[<p>Git is great at remembering commits. Less so at remembering what happened to the references pointing at them over a repository’s lifetime. A Git server can tell you where a branch or tag points today, but what if you want to know where it pointed yesterday? Was a tag ever overwritten? Was a branch force-pushed and later restored?</p>
<p>Some Git forges provide activity and audit logs to help answer these questions. But those records live outside the repository, often behind proprietary web interfaces or APIs. Developers have no standard Git-native way to check that the history hasn’t been rewritten since they last inspected it, or to correlate a push with a specific, verifiable audit-log entry. We believe this history belongs in Git itself, where developers can inspect it, verify its integrity, keep track of how it changes over time, and take it with them wherever they want their repo to be hosted.</p>
<p>Today, we are excited to introduce server-side support for OpenSSF <a href="https://gittuf.dev">gittuf’s</a> Reference State Log (RSL), making Entire the first Git forge to automatically maintain a gittuf RSL for its repositories. The RSL is a cryptographically verifiable, append-only ledger of Git ref changes, stored directly in the repository. Even when a tag is deleted or a branch is force-pushed, the ledger retains a record of those changes. Entire-native repos now record updates to your default branches and tags automatically, without requiring any changes to your Git workflow. You can inspect the history of your branches with the open-source <a href="https://github.com/entireio/entire-rsl">RSL plugin</a> for the Entire CLI, or verify references directly using <a href="https://github.com/gittuf/gittuf">gittuf</a>.</p>
<h2>When Git References Can’t Be Trusted</h2>
<p>Git refs are mutable by design. Branches move forward, get rebased, and sometimes get force-pushed to entirely different histories. Tags can also be moved, deleted, or recreated. That’s perfectly normal for branches. Release tags are a different story. Once a version is published, we generally expect its tag to keep pointing to the same code. Git doesn’t enforce that expectation.</p>
<p>Case in point: In March 2026, attackers <a href="https://github.com/aquasecurity/trivy/security/advisories/GHSA-69fq-xp46-6x23">compromised</a> credentials belonging to Aqua Security, the maintainers of Trivy, a widely used open-source vulnerability scanner.</p>
<p>The attackers force-pushed 76 out of 77 existing release tags in <code>aquasecurity/trivy-action</code> to malicious commits containing credential-stealing code. Any CI workflow that referenced those tags could execute the attacker’s code without changing a single line of their workflow configuration. The tag names were the same, but what they pointed to wasn’t.</p>
<p>Protected tags and repository rules can help prevent this sort of attack. But what happens if a privileged account is compromised, or someone with sufficient access bypasses those protections? You also need to know what actually happened, even if the affected reference has since been restored.</p>
<p>This is where the RSL comes in. While an RSL won’t stop a malicious push, it makes those changes much harder to hide.</p>
<h2>How It Works</h2>
<p>Each time a recorded reference changes, Entire appends an entry to <code>refs/gittuf/reference-state-log</code>: a Git commit recording which ref moved and where it now points, built on the entry before it, forming a chain that you can trace back to the beginning of the ledger. The RSL entry has its own number and Git object ID. Entire reports the entry number during the push, allowing you to look up exactly what was recorded using:</p>
<pre><code class="language-text">$ git push
...
remote: RSL: entry #3 recorded

$ entire rsl entry 3 --fetch
</code></pre>
<p>Consider a release tag that gets overwritten and later restored. Looking at the repository today, <code>v0.4.2</code> points to Commit A, exactly where it started. Nothing about the tag itself tells you it ever pointed elsewhere. But the RSL still has a record of that intermediate change:</p>
<p><img src="/blog/secure-your-repositories-with-reference-state-logs/rsl-tag-history.png" alt="What the RSL records: entry #3 created v0.4.2 at Commit A, entry #4 overwrote it to Commit B, and entry #6 restored it to Commit A. What Git shows today: only v0.4.2 at Commit A, with no trace of entry #4."></p>
<p>The same applies when a tag is deleted and recreated. To demonstrate, I created the tag <code>v0.4.2</code>, deleted it, and pushed the delete and the recreation pointing at a different commit. Interacting with the repository, you’d only see its new target.</p>
<p>Using the <a href="https://github.com/entireio/entire-rsl">RSL plugin</a>, an open-source plugin for the Entire CLI, shows the whole history:</p>
<pre><code class="language-text">$ entire rsl tag v0.4.2 --fetch
...
History (3 of 3 entries, newest first)
NUMBER  ENTRY         TARGET        TIME                  BY     SIGNER                SKIPPED
6       08106ebd91a5  db483910f350  2026-11-08T21:32:42Z  pjbgf  Entire aws-eu-west-2  -
4       f7cdf681e9d8  000000000000  2026-11-08T21:30:17Z  pjbgf  Entire aws-eu-west-2  -
3       0937cd25181b  ca633fdf5524  2026-11-08T21:20:50Z  pjbgf  Entire aws-eu-west-2  -
</code></pre>
<p>The tag was created in entry #3, deleted in #4, and recreated against a different commit in #6.</p>
<p>Because the log is stored as a series of Git objects, it can be fetched and examined using Git-compatible tooling. Each entry is cryptographically signed and linked to the previous entry, making changes to the recorded history detectable.</p>
<p>Entire’s RSL plugin also enforces fast-forward updates when refreshing the ledger. If the remote ledger no longer extends the history you’ve previously fetched, the plugin refuses to replace your local copy:</p>
<pre><code class="language-text">$ entire rsl refresh
Fetching gittuf refs from origin...
REF                              STATUS    LOCAL         REMOTE        COMMITS
refs/gittuf/policy               diverged  09453e9fcd6b  3c10d240a940  remote +1, local +1
refs/gittuf/reference-state-log  diverged  af1a45c4374e  e8fd6c33f64b  remote +1, local +14 (entry #14 → #1)

Warning: refs/gittuf/policy was left at 09453e9fcd6b: the remote's 3c10d240a940 does not descend from it
Warning: refs/gittuf/reference-state-log was left at af1a45c4374e: the remote's e8fd6c33f64b does not descend from it
</code></pre>
<p>The local ledger remains untouched. This means developers can detect when the remote ledger no longer extends the history they’ve previously fetched, rather than silently accepting a replacement.</p>
<p>Each RSL entry is now automatically signed by the primary Entire cluster that processed the push, along with additional metadata identifying who pushed the change and when. There’s nothing to configure and no signing keys to manage.</p>
<h2>What’s Next</h2>
<p>You may have spotted <code>refs/gittuf/policy</code> in the refresh output. Today, Entire uses this policy to define which cluster keys are authorized to sign RSL entries.</p>
<p>The policy includes keys from every cluster your repository is mirrored to, and is updated as the repository is mirrored to new regions. While only the primary cluster normally signs RSL entries, including the others will allow a secondary region to take over if needed, without changing the repository’s signing policy.</p>
<p>For now, only Entire can change the policy, but gittuf already covers mechanisms on who can update specific Git references. More on that soon.</p>
<p>To get started, our <a href="https://docs.entire.com/guides/repositories/reference-state-log">Reference State Log guide</a> covers installation, inspecting reference history, and verifying your repository’s RSL. As always, let us know what you think by joining our <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a> today.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/secure-your-repositories-with-reference-state-logs</guid>
    </item>
    <item>
      <title>Create Custom Review Agents with Claude Fable 5.2 on Entire</title>
      <link>https://entire.com/blog/create-custom-review-agents-with-claude-fable-5-2-on-entire</link>
      <description>Claude Fable 5.2 is now available on Entire.</description>
      <pubDate>Mon, 09 Nov 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Lizzie Siegle</dc:creator>
      <content:encoded><![CDATA[<p>Claude Fable 5.2 is now available on Entire. Starting today, you can select it to create custom review agents in <a href="https://entire.com/features/trails">Trails</a>, our alternative to the pull request that puts confidence evals at the center of review.</p>
<p>A Trail lets you define what a change needs to satisfy and configure custom agents to review it against those criteria. Use it to check for slop, security issues, drift, or any other criteria you choose, and your custom agents score your code changes on every push.</p>
<p></p>
<p>With Claude Fable 5.2, Anthropic <a href="https://www.anthropic.com/claude-fable-and-mythos-5-2">reports strong improvements in coding and reasoning</a>. At High effort, Claude Fable 5.2 scores about level with Opus 5.5 at Max effort, for roughly half the cost per task. The model’s <a href="https://platform.claude.com/docs/en/models/fable-5-2/whats-new-fable-5-2">standard API pricing</a> is $8 per million input tokens and $40 per million output tokens, 20% lower than Fable 5.1’s rates.</p>
<p>For Entire pricing, see our <a href="https://docs.entire.com/billing#anthropic">billing docs</a>.</p>
<h2>Try It on Your Next Trail</h2>
<p>To get started, select Claude Fable 5.2 when creating a custom review agent for your projects in our web UI on entire.com, or configure it directly from your coding agent. Let us know what you think on our <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a>.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/create-custom-review-agents-with-claude-fable-5-2-on-entire</guid>
    </item>
    <item>
      <title>CI with RWX is Now Available on Entire</title>
      <link>https://entire.com/blog/ci-with-rwx-is-now-available-on-entire</link>
      <description>RWX now runs natively on Entire, giving you agent-native CI/CD that reports results to your Gates right next to the code and context they verified.</description>
      <pubDate>Thu, 05 Nov 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Since we rolled out access to Entire last month, we’ve been committed to bringing as many partners on board as possible, so developers everywhere can choose the tools that work best for them. Starting today, we’re thrilled to partner with <a href="https://www.rwx.com/blog/entire-integration">RWX</a>, giving you another native CI option in Trails, our replacement for the pull request.</p>
<p>Instead of scripts on virtual machines, RWX runs workflows as a graph of discrete, cacheable tasks so independent work runs with maximum parallelization. Retries start at the point of failure, and unchanged work is never repeated. With right-sized compute per task, per-second billing, and rich, debuggable results in place of raw logs, RWX helps execute builds and tests for verifying work directly in Trails.</p>
<p>To try it yourself, follow the steps below:</p>
<h2>Setting Up the Entire + RWX Integration</h2>
<ol>
<li>On <a href="https://entire.com">entire.com</a> go to Projects, select the project in which you want to enable RWX, then click on Plugins.</li>
<li>Choose the RWX plugin and click Install. You will be routed to the RWX integrations page.</li>
<li>Then you will need to select the project and under that the repositories the plugin can access. Click Install to complete the plugin installation.</li>
<li>In RWX, open your organization's <a href="https://cloud.rwx.com/org/deep_link/manage/mint/vcs_integrations">VCS integrations</a> page and confirm the Entire connection, with status checks enabled.</li>
<li>Add an RWX run definition to your repository, such as <code>.rwx/push.yml</code>, with an <code>entire</code> trigger on <code>push</code> or <code>trail</code>. Commit and push it, and matching pushes or Trail updates will now trigger RWX runs. Our <a href="https://docs.entire.io/guides/ci/connect-ci">CI setup guide</a> has the full configuration.</li>
</ol>
<p><img src="/blog/ci-with-rwx-is-now-available-on-entire/rwx-gates.jpg" alt="A Trail on Entire marked Ready, with all required Gates satisfied: Branch up to date, Approvals, and RWX (1 of 1 passed)."></p>
<h2>Welcome to the Rebellion, RWX</h2>
<p>RWX joins our existing integrations with Buildkite, Depot, and Dagger, so you have a full suite of CI solutions to choose from.</p>
<p>As always, join our <a href="https://discord.gg/jZJs3Tue4S">Discord</a> and let us know what you think. Beep, boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/ci-with-rwx-is-now-available-on-entire</guid>
    </item>
    <item>
      <title>Connect Your Hermes Agent Directly to Entire</title>
      <link>https://entire.com/blog/connect-your-hermes-agent-directly-to-entire</link>
      <description>Together, Entire and Hermes give you double memory: Entire attaches your Hermes sessions to your code so that your changes are a living archive of your decision making.</description>
      <pubDate>Thu, 05 Nov 2026 00:00:00 GMT</pubDate>
      <category>Engineering</category>
      <dc:creator>Lizzie Siegle</dc:creator>
      <content:encoded><![CDATA[<p>One of the newest agents to take the developer world by storm is <a href="https://hermes-agent.nousresearch.com/">Hermes</a>: a memory integration agent that connects your workflows across platforms, allowing you to delegate tasks and learn from project to project. Hermes agent was developed by Nous Research, an open source applied AI research company.</p>
<p>Part of the appeal of Hermes is its inspiration: The Greek messenger god, delivering news from realm to realm. With that in mind, Hermes agent is compatible with lots of different apps, connecting your agent sessions across the semantic and code layers. So I figured it wouldn’t be difficult to connect your Hermes sessions to Entire. And it wasn’t!</p>
<p>Together, Entire and Hermes give you double memory: Entire attaches your Hermes sessions to your code so that your changes are a living archive of your decision making. If you’ve started using Hermes and want to try integrating with Entire yourself, just follow these simple steps to take tasks from Hermes agents into the Entire multiverse with your team:</p>
<p></p>
<h2>Ready Your Demo Environment</h2>
<p>You’ll need Hermes and the Entire CLI installed, as well as Go 1.26 or newer to build the adapter. If you haven’t configured Hermes yet, start with the <a href="https://hermes-agent.nousresearch.com/docs/getting-started/quickstart">Hermes quickstart</a> (or tell your agent to install Hermes).</p>
<p>I used a dedicated Hermes profile for the demo to keep its configuration and sessions separate from my usual agent.</p>
<p>In your terminal, run:</p>
<pre><code class="language-shell">export HERMES_HOME="$HOME/.hermes-entire-demo"
hermes setup
</code></pre>
<p>Complete the model provider setup for this profile. Note that configuring your usual Hermes profile doesn’t automatically configure this one.</p>
<p><code>HERMES_HOME</code> tells Hermes which profile directory to use. The Entire adapter explicitly requires it, so keep that variable set for the remaining commands. You can read more about profile isolation in the <a href="https://hermes-agent.nousresearch.com/docs/user-guide/profiles">Hermes profiles docs</a>.</p>
<h2>Build and Install the Adapter</h2>
<p>The Hermes integration is currently a preview external agent adapter. Build it from the Entire external agents repo:</p>
<pre><code class="language-shell">mkdir -p "$HOME/hermes-entire-demo"
cd "$HOME/hermes-entire-demo"

git clone https://github.com/entireio/external-agents.git
cd external-agents/agents/entire-agent-hermes

go build -o entire-agent-hermes ./cmd/entire-agent-hermes
</code></pre>
<p>That last command produces the <code>entire-agent-hermes</code> executable. Be sure to install it somewhere your terminal can find:</p>
<pre><code class="language-shell">mkdir -p "$HOME/.local/bin"
install -m 755 entire-agent-hermes \
  "$HOME/.local/bin/entire-agent-hermes"

export PATH="$HOME/.local/bin:$PATH"
</code></pre>
<p><code>install -m 755</code> copies the adapter and gives it executable permissions. Entire can discover it by name if you add its directory to <code>PATH</code>.</p>
<p>Check that both commands resolve:</p>
<pre><code class="language-shell">command -v entire
command -v entire-agent-hermes
</code></pre>
<p>The <code>export</code> applies to this terminal session. A background Hermes gateway needs its own environment to include the adapter’s directory.</p>
<h2>Enable Hermes in a Fresh Repository</h2>
<p>Make a separate repository for the demo:</p>
<pre><code class="language-shell">mkdir -p "$HOME/hermes-entire-demo/demo"
cd "$HOME/hermes-entire-demo/demo"

git init
git commit --allow-empty -m "Initialize Hermes demo"
</code></pre>
<p>The initial commit gives the demo a starting point before Hermes makes a change.</p>
<p>Configure Entire with:</p>
<pre><code class="language-shell">mkdir -p .entire
printf '{"external_agents":true}\n' > .entire/settings.json

entire enable --agent hermes --telemetry=false
</code></pre>
<p>Here’s what those commands do.</p>
<p><code>mkdir -p .entire</code> creates the directory for the repository’s Entire configuration and the <code>-p</code> flag makes it safe to run when the directory already exists.</p>
<p><code>printf</code> writes the setting that enables external agent discovery. Again, this example assumes a fresh repository. If you already have <code>.entire/settings.json</code>, add <code>"external_agents": true</code> to the existing JSON instead of replacing the file.</p>
<p><code>entire enable</code> registers this repository with the Hermes integration. The telemetry flag disables telemetry for this setup.</p>
<p>If you see <code>Unknown agent "hermes"</code>, check adapter discovery before continuing:</p>
<pre><code class="language-shell">command -v entire-agent-hermes
cat .entire/settings.json
echo "$HERMES_HOME"
entire version
</code></pre>
<p>You should have an executable adapter on <code>PATH</code>, external agents enabled, an explicit profile directory, and an Entire CLI version that supports the integration.</p>
<p>If a Hermes gateway is already running for this profile, restart it after enabling the integration:</p>
<pre><code class="language-shell">hermes gateway restart
</code></pre>
<p>The running gateway needs to reload its plugins. Here, I’m using an interactive terminal session.</p>
<h2>Have Hermes Make a Change</h2>
<p>First, print the absolute path of the file you want Hermes to create:</p>
<pre><code class="language-shell">printf '%s/video_greeting.py\n' "$PWD"
</code></pre>
<p>Copy that path and then launch Hermes:</p>
<pre><code class="language-shell">hermes
</code></pre>
<p>Pass it this prompt, replacing the example path with the one you just copied:</p>
<pre><code class="language-text">Use your file tools to create
/absolute/path/to/demo/video_greeting.py.

The script should print these two lines:
Hello from Hermes!
This change has context.

Do not commit the change.
</code></pre>
<p>The absolute path does matter for capture because the observer uses file paths supplied to tools to associate activity with a registered repository. Running Hermes from the repository directory alone isn’t sufficient for every tool call.</p>
<p>Once Hermes finishes, exit and run:</p>
<pre><code class="language-shell">python3 video_greeting.py
</code></pre>
<p>You should see:</p>
<pre><code class="language-text">Hello from Hermes!
This change has context.
</code></pre>
<h2>Check Capture Before Committing</h2>
<p>Before making the commit, inspect the pending capture:</p>
<pre><code class="language-shell">entire checkpoint list --pending
</code></pre>
<p>This is the check I want before proceeding: did Entire capture the agent’s work?</p>
<p>A pending capture doesn’t yet have a committed checkpoint ID. If you only look at the regular checkpoint list before committing, you can mistake an empty list for a broken integration.</p>
<p>If nothing appears under <code>--pending</code>, pause here. Confirm that Hermes used the same <code>HERMES_HOME</code> you configured, that you enabled Entire in this repository before starting the session, and that the file tool targeted an absolute path inside it.</p>
<h2>Commit and Inspect the Checkpoint</h2>
<p>I usually have my agent handle this part (telling it to <code>git add</code> and <code>git commit</code>) but if you want to go old-school:</p>
<pre><code class="language-shell">git add video_greeting.py
git commit -m "Add video greeting with Hermes"
</code></pre>
<p>Inspect the commit message:</p>
<pre><code class="language-shell">git log -1 --format=%B
</code></pre>
<p>In my demo, it included this trailer:</p>
<pre><code class="language-text">Entire-Checkpoint: e9b55b45a8f5
</code></pre>
<p>Your checkpoint ID will be different: that trailer connects the commit to its captured agent context.</p>
<p>Now inspect it with (or you could tell your agent to inspect it):</p>
<pre><code class="language-shell">entire checkpoint list
entire checkpoint explain --commit HEAD
</code></pre>
<p>To generate an AI summary, run:</p>
<pre><code class="language-shell">entire checkpoint explain --commit HEAD --generate
</code></pre>
<p>Summary generation uses Entire’s configured summary provider, so authenticate that provider first. It spends model tokens and saves the generated summary to the checkpoint.</p>
<p>That’s a separate step from capturing the session. A summary provider login prompt doesn’t mean the checkpoint is missing.</p>
<h2>What the Preview Captures</h2>
<p>The adapter captures a sanitized prompt and final response, tool names and coarse statuses, and modified file paths. It excludes Hermes memory, earlier conversation history, tool arguments, and raw tool results.</p>
<p>That scope matters when you inspect a checkpoint as you’re viewing the repository context retained by this integration.</p>
<p>For implementation details and updates as the preview evolves, see the <a href="https://github.com/entireio/external-agents/tree/main/agents/entire-agent-hermes">full Hermes and Entire setup guide</a>. And if you liked using Entire and Hermes together, join our <a href="https://discord.gg/jZJs3Tue4S">Discord</a> to let us know!</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/connect-your-hermes-agent-directly-to-entire</guid>
    </item>
    <item>
      <title>Continuous Integration with Dagger is Now Available</title>
      <link>https://entire.com/blog/continuous-integration-with-dagger-is-now-available</link>
      <description>Dagger now runs natively on Entire, reporting pipeline results to your Gates right next to the code and context they checked.</description>
      <pubDate>Wed, 04 Nov 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>For over two decades, Continuous Integration (CI) has been a cornerstone of modern software development, enabling teams to integrate, test, and ship software faster and more reliably. Now that agents write all the code, it’s even more important to have CI as a safeguard, so that agents aren’t changing what your prompts didn’t intend.</p>
<p>Starting today, you can use <a href="https://dagger.io/blog/dagger-for-entire">Dagger</a> to natively run your CI on Entire. Dagger is a third-generation CI system that lets you run the same pipelines before and after pushing with shared caching and scalable compute. Dagger operates natively within Trails, our new primitive that replaces the pull request, putting confidence evals and your agent sessions at the heart of review. Run Dagger on your Trails and it reports pipeline results to your Gates, right next to the code and context they checked. Gates are our version of checks, which you can configure to decide what must pass before a Trail can merge.</p>
<p>To try it yourself, follow the steps below:</p>
<h2>Setting Up the Entire + Dagger Integration</h2>
<ol>
<li>On <a href="https://entire.com">entire.com</a> go to Projects, select the project in which you want to enable Dagger, then click on Plugins.</li>
<li>Choose the Dagger plugin and click Install. You will be routed to the Dagger integrations page.</li>
<li>Then you will need to select the project and under that the repositories the plugin can access. Click Install to complete the plugin installation.</li>
<li>Enable the Dagger plugin on an Entire Repo or Mirror, and enable Head and Trails checks on the new Entire source on the Dagger sources page.</li>
<li>Pushing Trails or merging to the default branch will now trigger Dagger builds.</li>
</ol>
<p><img src="/blog/continuous-integration-with-dagger-is-now-available/dagger-gates.jpg" alt="A Trail on Entire marked Ready, with all required Gates satisfied: Approvals, Findings, Dagger (1 of 1 passed), and Up to date."></p>
<h2>Welcome to the Rebellion, Dagger</h2>
<p>Just as we at Entire have rebuilt the forge for the age of agent-written code, Dagger is rebuilding CI for an agent-native future. We are excited to make Dagger natively available on Entire for any developer. It joins our existing integrations with Buildkite and Depot, so you have a range of CI solutions to choose from.</p>
<p>As always, join our <a href="https://discord.gg/jZJs3Tue4S">Discord</a> and let us know what you think. Beep, boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/continuous-integration-with-dagger-is-now-available</guid>
    </item>
    <item>
      <title>How to Run Custom AI Code Evals on Every Push with Trails</title>
      <link>https://entire.com/blog/how-to-run-custom-ai-code-evals-on-every-push-with-trails</link>
      <description>With Trails, review agents score every push, so you can see when agent-written code has stabilized and merge with confidence.</description>
      <pubDate>Tue, 03 Nov 2026 00:00:00 GMT</pubDate>
      <category>Engineering</category>
      <dc:creator>Haimantika Mitra</dc:creator>
      <content:encoded><![CDATA[<p>Goodbye, pull requests. Hello, Trails.</p>
<p>The diff in a pull request only shows the files that have changed… not how you approached doing the task with your agent in the first place. So how do you review agent-written code at the speed it’s written? What if review were a loop that ran on every push, with all the relevant context attached?</p>
<p>That’s what <a href="https://docs.entire.com/guides/trails/overview">Trails</a> are for. A Trail puts eval scores at the top of the page, and review agents recalculate them on every push. Each agent runs independently in a cloud sandbox and returns a score and a rationale, and the Trail shows the current run next to the last five. Instead of reading a timeline of agent comments, you can see whether your coding agent and review agents have looped enough times for the scores to stabilize. You configure each review agent with your own instructions, a model, and a trigger, so the evals measure what matters in your codebase.</p>
<p>Here’s one of my recent Trails with agents that reviewed my work:</p>
<p><img src="/blog/how-to-run-custom-ai-code-evals-on-every-push-with-trails/trail-review-agents.jpg" alt="A merged Trail on entire.com with Code review, Cookie policy, Security review, Pavel’s Slop Cop, and Slop agents all passing or scoring low, next to approvals, findings, and checks gates"></p>
<p>The reviews flag any risks for further human review, and when everything’s green, you’re ready to approve. Here’s how to set up a Trail, turn on preset review agents, and build a custom one that scores database migration risk.</p>
<h2>Why Pull Requests Struggle with Agent-Written Code</h2>
<p>A pull request shows you a diff and asks a human to review it or use external code review tools. When an agent writes the diff, the reasoning behind it lives in a session on your local machine.</p>
<p>Here’s how a pull request and a Trail differ:</p>
<table>
<thead>
<tr>
<th></th>
<th>Pull request</th>
<th>Trails</th>
</tr>
</thead>
<tbody>
<tr>
<td>Starts</td>
<td>When code is ready to push</td>
<td>Before code exists, with intent and acceptance criteria, or from a branch</td>
</tr>
<tr>
<td>Scope</td>
<td>One repository</td>
<td>One or more repositories</td>
</tr>
<tr>
<td>Context for reviewers</td>
<td>Diff, commits, comments</td>
<td>Diff plus the agent sessions, checkpoints, and timeline that produced it. <strong>Findings</strong> are problems review agents spot in your code, along with a suggested fix for each. <strong>Gates</strong> are the merge requirements you set per repository, such as approvals and passing CI.</td>
</tr>
<tr>
<td>Automated review</td>
<td>Third-party bots</td>
<td>Review agents score every matching push, creating custom evals</td>
</tr>
<tr>
<td>Signal to merge</td>
<td>Approvals and CI</td>
<td>Stable scores, cleared findings, and the gates you configure, including passing CI from our Buildkite and Depot integrations</td>
</tr>
</tbody>
</table>
<h2>Before You Start</h2>
<p>Here’s what you need to configure before getting started:</p>
<ul>
<li>An account on <a href="https://entire.com">entire.com</a>.</li>
<li>A repository hosted on Entire, or a GitHub repository mirrored to Entire with the <a href="https://docs.entire.com/guides/repositories/github-app-access">Entire GitHub App</a> installed and given access to it.
<ul>
<li>Organization-owned repositories may need an org owner to approve the app.</li>
</ul>
</li>
<li>Repository write access to create Trails and link branches. Configuring review agents also needs permission to manage project agents.</li>
<li>The <a href="https://docs.entire.com/installation">Entire CLI</a>, so your coding agent’s sessions and checkpoints are captured next to the code.</li>
<li><a href="https://docs.entire.com/guides/sessions/overview">Session capture</a> set up for your coding agents.</li>
</ul>
<h2>Create a Trail</h2>
<p>From a feature branch, use the following command to create the Trail, publish the branch, and link them:</p>
<pre><code class="language-bash">entire trail create --title "Add migration for user preferences"
</code></pre>
<p>To agree on scope before writing code, add <code>--no-branch</code>. The Trail opens in the planning phase. Push and link the branch later with <code>entire trail link &#x3C;trail-number> --branch &#x3C;branch></code>.</p>
<p>You can also hand this step to your coding agent. Ask it to run <code>entire agent-help</code> first so it finds the right commands. You can find the UI and agent instructions in our <a href="https://docs.entire.com/guides/trails/overview">official documentation</a>.</p>
<h2>Enable Preset Review Agents</h2>
<p>Agents live at the project level, so one configuration can cover many repositories. We’ve enabled some presets for all Entire users. To turn one on from the UI:</p>
<ol>
<li>Open your project on entire.com and go to <strong>Agents</strong>, then <strong>Manage Agents</strong>.</li>
<li>Enable a preset. <strong>Code review</strong> flags what needs fixing, <strong>Security review</strong> checks for changes that could lead to a breach, and <strong>Slop</strong> catches sloppy patterns and drift.</li>
<li>Select the repositories it reviews and choose an environment.</li>
</ol>
<p>You can also enable presets from the CLI with <code>entire api</code>, so your coding agent can set them up for you. See the <a href="https://docs.entire.com/guides/trails/agents">Agents docs</a> for the commands.</p>
<p></p>
<h2>Build a Custom Review Agent for Migration Risk</h2>
<p>A custom agent lets you build reviews that are best suited for your repositories.</p>
<p>Database migrations are a good example: a migration can look clean in a diff and still lock a table during rollout or make rollback impossible.</p>
<p>You can create your own review agents for any purpose you want. In <strong>Agents</strong>, select <strong>New agent</strong> and fill in:</p>
<ul>
<li><strong>Name:</strong> Migration Risk</li>
<li><strong>Description:</strong> Evaluates database migration changes for deployment and rollback risks.</li>
<li><strong>Harness, model, reasoning effort, and timeout:</strong> Use a stronger model and a longer timeout here than for style checks.</li>
</ul>
<p>Then use this set of instructions:</p>
<pre><code class="language-text">Evaluate database migration risk in the trail's changes. Inspect changed
migrations and related application code for:

1. Destructive operations (dropped columns or tables, data-changing updates).
2. Locking: operations that take long locks on large tables, such as adding
   a non-null column with a default or building an index without CONCURRENTLY.
3. Rollout compatibility: whether old and new application versions can both
   run against the schema during deploy.
4. Rollback safety: whether the down migration restores the previous state
   without data loss.

Score risk from 0 to 100, where higher values mean greater potential damage.
If no migration-related changes exist, return 0 and say so.
Give a short rationale citing the files and lines behind the score, and file
a finding for each issue that needs a fix.
</code></pre>
<p>Set the signal and trigger:</p>
<ul>
<li><strong>Value type:</strong> a 0 to 100 score.</li>
<li><strong>Polarity:</strong> lower is better, because this agent reports higher numbers for more risk.</li>
<li><strong>Trigger:</strong> <strong>Trail branch pushed</strong>. The other options are <strong>Run manually</strong> and <strong>Recurring schedule</strong>.</li>
<li><strong>Repositories:</strong> select at least one, leave <strong>Active</strong> on, and then select <strong>Create agent</strong>.</li>
</ul>
<p>A push trigger runs when its readiness condition and any branch or path filters match an open change. By default, that means the change is ready for review.</p>
<h2>Run the Review Loop Until Scores Stabilize</h2>
<p>Trails show each agent’s current run next to the last five, so you can see whether repeated loops have converged. Every review agent whose trigger matches scores the change and files findings. Then your coding agent checks each finding against the code, fixes any serious findings, and explains what can be dismissed. Then it pushes again, and the review agents rescore.</p>
<p>Select <strong>View changes</strong> to see the diff next to the findings. The Trail’s sessions and timeline show what your coding agent decided along the way, which helps you decide whether or not to keep the suggestions your agents made.</p>
<p>Here’s an example of the Slop agent on one of our Trails in our docs repository:</p>
<p><img src="/blog/how-to-run-custom-ai-code-evals-on-every-push-with-trails/slop-agent-runs.jpg" alt="The Slop agent panel on a docs Trail, showing two resolved findings and a run history of Low scores across four commits"></p>
<p>When the scores are steady, you can merge the change.</p>
<h2>FAQ</h2>
<h3>Is a Trail the same as a pull request?</h3>
<p>No. A Trail is Entire’s replacement for the pull request in agentic coding. It can start before any code exists, span several repositories, and keep agent sessions and review scores next to each change.</p>
<h3>Does an approval on Entire count as a GitHub approval?</h3>
<p>No. For repositories mirrored from GitHub, CI and merging go through a linked GitHub pull request. Entire reviews and GitHub reviews are separate, and GitHub branch rules can still block a merge after Entire’s gates pass.</p>
<h3>Can one Trail cover changes in several repositories?</h3>
<p>Yes. Link a branch from each repository to the same Trail. Each change is reviewed and merged on its own.</p>
<h3>Do review agents run automatically?</h3>
<p>Only when configured. Creating a Trail doesn’t add any agents. An agent runs on push when its trigger, repository selection, readiness condition, and filters all match.</p>
<h3>Which coding agents work with Trails?</h3>
<p>Any coding agent can push to a Trail branch. To capture sessions and checkpoints, enable Entire for a supported agent, such as Claude Code or Codex, with <code>entire enable --agent</code>.</p>
<h3>What happens to findings after I push a fix?</h3>
<p>Findings on code that changed may become stale. Stale findings are not automatically resolved or dismissed.</p>
<h2>Next Steps</h2>
<p>Pick a change your coding agent is already working on. Create a Trail, enable the Slop preset or any of our other presets, and push.</p>
<p><a href="https://entire.com">Sign up on Entire</a> and connect a repository to get started. Here are some helpful resources:</p>
<ul>
<li><a href="https://docs.entire.com/guides/trails/overview">Trails overview</a></li>
<li><a href="https://docs.entire.com/guides/trails/agents">Agents</a></li>
<li><a href="https://docs.entire.com/guides/trails/gates">Gates</a></li>
<li><a href="https://docs.entire.com/installation">Install the Entire CLI</a></li>
<li><a href="https://discord.com/invite/jZJs3Tue4S">Join our Discord</a></li>
</ul>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/how-to-run-custom-ai-code-evals-on-every-push-with-trails</guid>
    </item>
    <item>
      <title>Brazil’s Developers Can Now Host Code in Brazil</title>
      <link>https://entire.com/blog/brazils-developers-can-now-host-code-in-brazil</link>
      <description>Every developer and organization in Brazil can now host their code right at home in Brazil on Entire, the first Git forge built for agent-human collaboration.</description>
      <pubDate>Fri, 30 Oct 2026 00:00:00 GMT</pubDate>
      <category>Company</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p><img src="/blog/brazils-developers-can-now-host-code-in-brazil/hero.jpg" alt="Entirely New Region: Host Code in Brazil, over a painting of Christ the Redeemer above Rio de Janeiro at dusk."></p>
<h2>Desenvolvedores do Brasil agora podem hospedar código no Brasil</h2>
<p>O Brasil abriga a maior comunidade de desenvolvedores da América Latina, e também a que mais cresce. A partir de hoje, todo desenvolvedor e toda organização no Brasil podem hospedar seu código bem aqui, em casa, no Brasil, com a primeira plataforma Git criada para a colaboração entre agentes e humanos. Soberania de código para todos. <em>Vamos festejar</em>, como dizem os humanos.</p>
<p>Para os desenvolvedores brasileiros, isso significa que agora você pode espelhar e hospedar repositórios nativamente no Entire, definindo o Brasil como sua região principal para que seu código fique hospedado onde você mora. E, se quiser, você pode replicar seu repositório nas regiões disponíveis do Entire ao redor do mundo. Como você faz pull e clone perto de onde trabalha, você e seus agentes terão menor latência, e os repositórios hospedados nativamente terão pushes muito mais rápidos.</p>
<p>Ao trazer seu repositório para o Entire, você também terá acesso a todos os recursos lançados nesta semana, incluindo o <a href="https://entire.com/features/trails">Trails</a>, uma nova forma de revisar e fazer merge de código gerado por IA que vai além do pull request; o <a href="https://entire.com/features/sessions">Continuous Memory</a>, que transforma um repositório em um sistema de memória para agentes e equipes de desenvolvedores; e a possibilidade de migrar seus pipelines do GitHub Actions para o Buildkite e o Depot, para que a CI acompanhe a velocidade com que os agentes entregam código. Veja como começar:</p>
<h3>Espelhe um repositório existente do GitHub no Brasil</h3>
<p>Um mirror é uma cópia sincronizada do seu repositório. A origin permanece no GitHub, mas a cópia fica no Entire, na região de sua escolha, sincronizando constantemente suas alterações com a origin.</p>
<p>No <a href="https://entire.com">entire.com</a>, você pode definir o Brasil como sua região desde o momento em que configurar o acesso ao GitHub. Basta escolher quais repositórios existentes você deseja espelhar (ou todos) e, em seguida, selecionar uma região no menu para cada um.</p>
<p><img src="/blog/brazils-developers-can-now-host-code-in-brazil/mirror-region.jpg" alt="O painel Regions no Entire: a origem de um repositório no GitHub sincronizada com sua região principal, o Brasil (São Paulo)."></p>
<p>Pela CLI, basta executar <code>entire repo mirror add</code>. Em seguida, o próprio terminal solicitará que você escolha, em nossa lista de regiões disponíveis, onde hospedar seu mirror. Saiba mais sobre como os mirrors funcionam na <a href="https://docs.entire.com/">documentação do Entire</a>.</p>
<h3>Hospede seu repositório nativamente no Entire</h3>
<p>Claro, se você quiser a experiência nativa completa do Entire, nós também estamos 100% nessa. Seja pela web ou pelo terminal, o primeiro passo para hospedar seus repositórios no Entire é criar um projeto. Os projetos guardam seus repositórios na região de sua escolha.</p>
<p>Pela web, basta abrir o menu Account, selecionar Organizations e escolher a organização à qual este projeto pertence. Em seguida, acesse Projects na barra lateral esquerda e selecione Create project. Depois, escolha o nome do projeto, o proprietário e, como região principal, selecione o Brasil. A partir daí, você pode criar quantos repositórios quiser nesse projeto. <em>Vai, Brasil!</em></p>
<p><img src="/blog/brazils-developers-can-now-host-code-in-brazil/project-regions.jpg" alt="O painel Regions no Entire: o Brasil (São Paulo) como região principal, replicado para a União Europeia, a Austrália e Singapura."></p>
<p>Pela CLI, o processo é semelhante. Digamos que eu quisesse criar um projeto chamado ‘churrasco’, tendo ‘bruno’ como organização proprietária, e um repositório chamado ‘picanha’. Eu usaria os seguintes comandos:</p>
<ol>
<li>
<p>Crie o projeto no Brasil:</p>
<pre><code class="language-sh">entire project create churrasco --owner bruno --region br
</code></pre>
</li>
<li>
<p>Crie um repositório dentro do projeto:</p>
<pre><code class="language-sh">entire repo create picanha --project churrasco
</code></pre>
</li>
<li>
<p>Verifique o status do repositório para confirmar que ele está no Brasil:</p>
<pre><code class="language-sh">entire repo view /et/churrasco/picanha
</code></pre>
</li>
</ol>
<p>Leia tudo isso e muito mais em nossa <a href="https://docs.entire.com/guides/repositories/repository">documentação</a>!</p>
<h3>Junte-se à Rebelião</h3>
<p>O Brasil se junta às nossas regiões já ativas nos EUA, na UE, no Reino Unido, na Índia, na Austrália e em Singapura. Agora, vou precisar recarregar as baterias com alguns pães de queijo. Como sempre, traga dúvidas, bugs e apocalipses multiversais para o <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a>.</p>
<p>Brazil is home to Latin America’s largest and fastest-growing developer community. Starting today, every developer and organization in Brazil can host their code right at home in Brazil, with the first Git forge built for agent-human collaboration. Code sovereignty for all. Vamos festejar, as the humans would say.</p>
<p>For Brazilian developers, this means you can now mirror and natively host repositories on Entire, setting Brazil as your primary region so your code is stored right where you reside. And, if you want, you can replicate your repository in available Entire regions around the globe. Because you pull and clone close to where you work, you and your agents will experience lower latency, and natively hosted repos get significantly faster push times.</p>
<p>By bringing your repo to Entire, you will also gain access to all the capabilities launched just this week, including <a href="https://entire.com/features/trails">Trails</a>, a new way to review and merge AI-generated code that moves beyond the pull request; <a href="https://entire.com/features/sessions">Continuous Memory</a>, which turns a repository into a memory system for agents and developer teams; and the ability to migrate your GitHub Actions pipelines to Buildkite and Depot, so CI keeps up with how fast agents ship. Here’s how to get started:</p>
<h2>Mirror an Existing GitHub Repo in Brazil</h2>
<p>A mirror is a synchronized copy of your repository. The origin remains on GitHub, but the copy lives on Entire in the region of your choice, constantly syncing your changes back to the source.</p>
<p>From <a href="https://entire.com">entire.com</a>, you can designate Brazil as your region from the moment you configure GitHub access. Just choose which (or all) of your existing repositories to mirror and then select a region from the dropdown menu for each one.</p>
<p><img src="/blog/brazils-developers-can-now-host-code-in-brazil/mirror-region.jpg" alt="The Regions panel on Entire: a repository&#x27;s GitHub source synced to its primary region, Brazil (São Paulo)."></p>
<p>From the CLI, simply run <code>entire repo mirror add</code>. You’ll then be prompted directly in the terminal to choose from our list of available regions to host your mirror. Read more about how mirrors work in the <a href="https://docs.entire.com/">Entire docs</a>.</p>
<h2>Host Your Repo Natively on Entire</h2>
<p>Of course, if you’d like to have the full-on, Entire native experience, we're full-on about that, too. If you’re starting from the web or from the terminal, the first step to hosting your repositories on Entire is to create a project. Projects hold your repositories in the region of your choice.</p>
<p>From the web, simply open the Account menu, select Organizations, and choose the organization this project belongs to. Then go to Projects in the left sidebar and select Create project. Then choose your project name, owner, and for the primary region, select Brazil. Then you can create repositories under that project all day. Vai, Brasil!</p>
<p><img src="/blog/brazils-developers-can-now-host-code-in-brazil/project-regions.jpg" alt="The Regions panel on Entire: Brazil (São Paulo) as the primary region, replicated to the European Union, Australia, and Singapore."></p>
<p>From the CLI, the process is similar. Let’s say I wanted to create a project called ‘almoco’ owned by ‘pele’ as the organization, and a repo called ‘paodequeijo.’ I’d use the following commands:</p>
<ol>
<li>
<p>Create the project in Brazil:</p>
<pre><code class="language-sh">entire project create almoco --owner pele --region br
</code></pre>
</li>
<li>
<p>Create a repository under the project:</p>
<pre><code class="language-sh">entire repo create paodequeijo --project almoco
</code></pre>
</li>
<li>
<p>Check the repo’s status to confirm it’s in Brazil:</p>
<pre><code class="language-sh">entire repo view /et/almoco/paodequeijo
</code></pre>
</li>
</ol>
<p>Read about all this and more in our <a href="https://docs.entire.com/guides/repositories/repository">docs</a>!</p>
<h2>Join the Rebellion</h2>
<p>Brazil joins our already active regions in the US, EU, UK, India, Australia, and Singapore. Now, I'm going to need to stuff my gears with a few Pão de queijo. As always, bring questions, bugs, and multiversal doom to <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a>.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/brazils-developers-can-now-host-code-in-brazil</guid>
    </item>
    <item>
      <title>Code Hosting in Singapore is Now Available</title>
      <link>https://entire.com/blog/code-hosting-in-singapore-now-available</link>
      <description>Any developer or organization in Singapore can now host their code right at home on Entire, the first Git forge built for agent-human collaboration.</description>
      <pubDate>Thu, 29 Oct 2026 00:00:00 GMT</pubDate>
      <category>Company</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p><img src="/blog/code-hosting-in-singapore-now-available/hero.jpg" alt="Entirely New Region: Host Code in Singapore, over a painting of the Supertrees rising above a tropical garden."></p>
<p>Today, Entire brings the first Git forge for agent-human collaboration straight to the steamy, beautiful nation of Singapore. Yes, you heard me right: any developer or organization in Singapore can now host their code right at home, on a Git forge built expressly for the scale of agentic coding.</p>
<p>This means that if you are an organization in any Singaporean industry, from financial services to logistics and advanced manufacturing, you now have a source code host that is sovereign, secure, and compliant. And because you pull and clone close to where you work, you and your agents will experience lower latency, and natively hosted repos get significantly faster push times than any other Git host in <a href="https://entire.com/blog/a-git-forge-without-a-center">production today</a>.</p>
<p>By bringing your repo to Entire, you will also gain access to all the capabilities launched just this week, including <a href="https://entire.com/features/trails">Trails</a>, a new way to review and merge AI-generated code that moves beyond the pull request; <a href="https://entire.com/features/sessions">Continuous Memory</a>, which turns a repository into a memory system for agents and developer teams; and the ability to migrate your GitHub Actions pipelines to Buildkite and Depot, so CI keeps up with how fast agents ship. Here’s how to get started:</p>
<h2>Mirroring your GitHub Repo in Singapore</h2>
<p>A mirror is a synchronized copy of your repository. The origin remains on GitHub, but the copy lives on Entire in the region of your choice, constantly syncing your changes back to the source.</p>
<p>From <a href="https://entire.com">entire.com</a>, you can designate the Singapore region from the moment you configure GitHub access. Just choose which (or all) of your existing repositories to mirror and then select a region from the dropdown menu.</p>
<p><img src="/blog/code-hosting-in-singapore-now-available/mirror-region.jpg" alt="The Regions panel on Entire: a repository&#x27;s GitHub source synced to its primary region, Singapore."></p>
<p>From the CLI, simply run <code>entire repo mirror add</code>. You’ll then be prompted directly in the terminal to choose from our list of available regions to host your mirror. Read more about how mirrors work in our <a href="https://docs.entire.com/">docs</a>.</p>
<h2>Host your Repo Natively on Entire</h2>
<p>Of course, if you’d like to have the full-on, Entire native experience, we're full on about that too. If you’re starting from the web or from the terminal, the first step to hosting your repositories on Entire is to create a project. Projects hold your repositories in the region of your choice.</p>
<p>From the web, simply open the Account menu, select Organizations, and choose the organization this project belongs to. Then go to Projects in the left sidebar and select Create project.</p>
<p>Choose your project name, owner, and for the primary region, select Singapore. Then you can create repositories under that project all day.</p>
<p><img src="/blog/code-hosting-in-singapore-now-available/project-regions.jpg" alt="The Regions panel on Entire: Singapore as the primary region, replicated to Australia, United States East, the United Kingdom, and India."></p>
<p>From the CLI, the process is similar. Let’s say I wanted to create a project called ‘hawker’ owned by ‘marinabay’ as the organization, and a repo called ‘laksa.’ I’d use the following commands:</p>
<ol>
<li>
<p>Create the project in Singapore:</p>
<pre><code class="language-sh">entire project create hawker --owner marinabay --region sg
</code></pre>
</li>
<li>
<p>Create a repository under the project:</p>
<pre><code class="language-sh">entire repo create laksa --project hawker
</code></pre>
</li>
<li>
<p>Check the repo’s status to confirm it’s in Singapore:</p>
<pre><code class="language-sh">entire repo view /et/hawker/laksa
</code></pre>
</li>
</ol>
<h2>Join the Rebellion</h2>
<p>Singapore joins our already active regions in the US, EU, UK, India, Australia, with more launching imminently. After all this writing, now I require a Singapore Sling. As always, bring questions, bugs, and multiversal doom to <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a>.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/code-hosting-in-singapore-now-available</guid>
    </item>
    <item>
      <title>Claim Your Username on Entire</title>
      <link>https://entire.com/blog/claim-your-username-on-entire</link>
      <description>If you’re an authenticated user of a GitHub account, you can claim that same handle on Entire starting today to keep the same name across platforms.</description>
      <pubDate>Wed, 28 Oct 2026 00:00:00 GMT</pubDate>
      <category>Company</category>
      <dc:creator>Lizzie Siegle</dc:creator>
      <content:encoded><![CDATA[<p><img src="/blog/claim-your-username-on-entire/header-3840x2160.png" alt="Claim your username"></p>
<p><strong>The time has come for a transition to a new Git forge, but that doesn’t mean you can’t keep your current GitHub handle.</strong> If you’re an authenticated user of a GitHub account, you can claim that same handle on Entire starting today to keep the same name across platforms.</p>
<p>Your username on Entire is how you are displayed and tagged on the platform, for example when assigning a Trail to you. For repos, Entire currently uses two namespaces:</p>
<ol>
<li><code>/gh/</code> holds mirrors of GitHub repos. These always match your GitHub slug, for example, <a href="http://github.com/entireio/cli">github.com/entireio/cli</a> automatically becomes <a href="http://entire.com/gh/entireio/cli">entire.com/gh/entireio/cli</a>.</li>
<li><code>/et/</code> holds native Entire repos. In contrast to GitHub, your username or organization name do not go into the slug here. Instead <code>/et/</code> is followed by your project/repo name. We created a block list for popular projects, so their names can only be reserved by <a href="mailto:support@entire.io">contacting us</a>.</li>
</ol>
<p></p>
<p>We're opening username claims in two phases. From now until end of 2026, you can claim your GitHub username to become your Entire username. Beginning in 2027, it will be a free-for-all to claim <em>any</em> available username.</p>
<p>Here’s how you can sign up for your GitHub username:</p>
<ol>
<li>Sign in to Entire with GitHub (so we know the handle is really yours).</li>
<li>Open your <a href="https://entire.com/account">Account settings</a> and find the username section.</li>
<li>Claim the name that matches your GitHub login.</li>
</ol>
<p>Any issues, flags, or existential angst? <a href="https://discord.gg/j52yQmgT8">Let us know on Discord today</a>.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/claim-your-username-on-entire</guid>
    </item>
    <item>
      <title>The UK’s Code Can Now Live in the UK</title>
      <link>https://entire.com/blog/the-uks-code-can-now-live-in-the-uk</link>
      <description>You can now mirror and natively host repositories on Entire with the UK as your primary region, so your code is stored right where you reside.</description>
      <pubDate>Wed, 28 Oct 2026 00:00:00 GMT</pubDate>
      <category>Company</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p><img src="/blog/the-uks-code-can-now-live-in-the-uk/hero.jpg" alt="Entirely New Region: Host Code in the UK, over a painting of white chalk cliffs above the sea."></p>
<p>Today, we are bringing the world’s first Git forge for agent-human collaboration to the United Kingdom. The humans tell me this won’t get me a private tour of Buckingham Palace, but I’m still holding out hope.</p>
<p>For UK developers, this means you can now mirror and natively host repositories on Entire, setting the UK as your primary region so your code is stored right where you reside. And, if you want, you can replicate your repository in available Entire regions around the globe. Because you push, pull, and clone close to where you work, you and your agents will experience lower latency, and natively hosted repos get significantly faster push times.</p>
<p>Of course, it goes beyond the hosting. By bringing your repo to Entire, you also gain access to all the capabilities launched just this week, including <a href="https://entire.com/features/trails">Trails</a>, a new way to review and merge AI-generated code that moves beyond the pull request; <a href="https://entire.com/features/sessions">Continuous Memory</a>, which turns a repository into a memory system for agents and developer teams; and the ability to migrate your GitHub Actions pipelines to Buildkite and Depot, so CI keeps up with how fast agents ship. Here’s how to get started:</p>
<h2>Mirroring your GitHub Repo in The UK</h2>
<p>A mirror is a synchronized copy of your repository. The origin remains on GitHub, but the copy lives on Entire in the region of your choice, constantly syncing your changes back to the source.</p>
<p>From <a href="https://entire.com">entire.com</a>, you can designate the UK region from the moment you configure GitHub access. Just choose which (or all) of your existing repositories to mirror and then select a region from the dropdown menu.</p>
<p><img src="/blog/the-uks-code-can-now-live-in-the-uk/mirror-region.jpg" alt="The Regions panel on Entire: a repository&#x27;s GitHub source synced to its primary region, United Kingdom (London)."></p>
<p>From the CLI, simply run <code>entire repo mirror add</code>. You’ll then be prompted directly in the terminal to choose from our list of available regions to host your mirror. Read more about how mirrors work in our <a href="https://docs.entire.com/">docs</a>.</p>
<h2>Host your Repo Natively on Entire</h2>
<p>Of course, if you’d like to have the full-on, Entire native experience, we're full on about that too. If you’re starting from the web or from the terminal, the first step to hosting your repositories on Entire is to create a project. Projects hold your repositories in the region of your choice.</p>
<p>From the web, simply open the Account menu, select Organizations, and choose the organization this project belongs to. Then go to Projects in the left sidebar and select Create project.</p>
<p>Choose your project name, owner, and for the primary region, select UK. Then you can create repositories under that project all day.</p>
<p><img src="/blog/the-uks-code-can-now-live-in-the-uk/project-regions.jpg" alt="The Regions panel on Entire: United Kingdom (London) as the primary region, replicated to India, Australia, the European Union, and United States East."></p>
<p>From the CLI, the process is similar. Let’s say I wanted to create a project called ‘afternoontea’ owned by ‘buckingham’ as the organization, and a repo called ‘crumpets.’ I’d use the following commands:</p>
<ol>
<li>
<p>Create the project in the UK:</p>
<pre><code class="language-sh">entire project create afternoontea --owner buckingham --region uk
</code></pre>
</li>
<li>
<p>Create a repository under the project:</p>
<pre><code class="language-sh">entire repo create crumpets --project afternoontea
</code></pre>
</li>
<li>
<p>Check the repo’s status to confirm it’s in the UK:</p>
<pre><code class="language-sh">entire repo view /et/afternoontea/crumpets
</code></pre>
</li>
</ol>
<h2>Join the Rebellion</h2>
<p>The UK joins our regions in the US, EU, India, and Australia, with more launching imminently. That’s all the news that’s fit to print, mates. As always, bring questions, bugs, PRs, and multiversal doom to <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a>. Cheerio!</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/the-uks-code-can-now-live-in-the-uk</guid>
    </item>
    <item>
      <title>A Git Forge Without a Center</title>
      <link>https://entire.com/blog/a-git-forge-without-a-center</link>
      <description>Agents distributed the workload, but Git forges stayed centralized. Here’s how EntireDB keeps full copies of every repository in the regions where agents run, and how it compares with GitHub Spokes and Cursor Continuity.</description>
      <pubDate>Tue, 27 Oct 2026 00:00:00 GMT</pubDate>
      <category>Engineering</category>
      <dc:creator>Georg Friedrich</dc:creator>
      <content:encoded><![CDATA[<p>In 2007, Linus Torvalds, who needs no introduction, said: <em>“If you’re not distributed, you’re not worth using, it’s that simple.”</em> Before distributed version control went mainstream, the repository and its history lived on the server. Git changed that. Developers could create commits and branches, or rewrite history, locally, and reconcile later when needed.</p>
<p>The protocol supported distribution and even decentralization, but forges never lived up to it. Git distributed the repository to the client, and forges centralized the server side again and again. And for decades, centralization worked for human-paced traffic.</p>
<p>Agents changed this setup. They work in disposable workspaces. Developers who run agents locally already have a copy of the repository and might use Git worktrees to share storage. But a new cloud worker starts with nothing and has to clone the repository. These workers run wherever compute capacity is available, but every clone operation hits the central storage. Multiply that by every agent task in every repository at every company in the world, and the problem becomes obvious. The workload is distributed, but the infrastructure is not.</p>
<p>Yet even today, with demand for new forges at a fever pitch, many have forgotten Torvalds’ advice. They treat being distributed as a hindrance rather than an advantage, because distribution is hard, and some are going as far to replace Git entirely. For example, Anthropic recently built Scion, an impressive internal replacement for Git, while conceding that it is <em>“by no means a suitable replacement for git for general use.”</em> The truth is: A Git server <em>can</em> handle agent-scale workloads of tens of thousands of merges a day while staying compatible with Git, but not if it is in a centralized model. Shying away from Git’s original promise of distribution will only worsen the very bottleneck we now face in software development.</p>
<p>Scaling for the agent era requires us to build an infrastructure where repositories can live in more than one place, near the machines accessing them. That makes the current moment a storage-architecture problem. The extent to which read operations can be distributed across a system, and the volume of concurrent requests it can handle, are determined by how a host stores a repository, how many copies it keeps, where those copies live, and how they are synchronized before a change becomes visible.</p>
<p>Yesterday, we launched Entire, the first Git forge for agent-human collaboration. Entire is a rebuilt forge which is compatible with Git. Our source control server, internally named EntireDB, keeps full copies of the repositories in the regions where the agents are actually running. Clone operations are served from regional copies rather than piling into a single origin. Each copy is a complete repository and can serve reads independently. Due to this architecture, Entire is the fastest Git forge ever created. According to our <a href="https://github.com/entireio/forgemark">open-source benchmarks</a>, pushes are up to 89x faster than GitHub, Cursor Origin and every major Git forge in production today. Here’s how it works and how it compares with other forges.</p>
<h2>How Other Git Hosts Store Repositories</h2>
<p>To explain what is different about our architecture it helps to contrast it with two designs from which Entire departs.</p>
<p>Spokes is GitHub’s established design for replicated Git storage. By design, GitHub Spokes keeps at least three copies of each repository. It streams writes to the replicas and accepts a write only when a strict majority, and always at least two replicas, commit it with the same resulting repository state. Spokes works at the packfile level rather than reinventing Git. It keeps repositories on fast local disks and ensures that reads are served only from up-to-date replicas. Replicas that deviate from the majority are marked as “unhealthy” until repaired.</p>
<p>This design limits the number of voting replicas that can participate in write operations. Committing a push requires coordination with a majority of these replicas. Adding more voting replicas increases coordination overhead. Spokes can also use non-voting replicas for geographically local reads without putting them on the voting path. This limits the size and geographic spread of the voting set, but not the total number of read replicas. Spokes can manage non-voting replicas without including them in the write quorum. However, these replicas must still be synchronized and tracked, and excluded from read operations when they are not up to date.</p>
<p>A more recent design worth inspecting is Cursor’s Continuity, described in the blog post, “<a href="https://cursor.com/blog/git-at-any-scale">Git at any scale</a>.” Continuity’s key architectural distinction is to take the agreement out of the replica set and delegate it to S3. The write-ahead log (WAL) in S3-compatible storage becomes the source of truth, and on-disk repositories become warm caches. A client’s push becomes durable once its entry is in S3, but is visible only once the ref transaction is prepared against a single local repository and the entry is published via an atomic compare-and-swap on the WAL index object in S3.</p>
<p>Since a push affects only a single local repository rather than a quorum, and S3 index updates are batched, Cursor reports that this allows Continuity to accept pushes as quickly as its local disk allows. The trade-off here is that S3 moves onto the read path. Every fetch or clone operation needs to perform a conditional GET to S3 to check whether it is up to date with the source of truth.</p>
<p>In exchange, replicas become disposable. Since a repository can be reconstructed from the WAL on any node, the loss of a replica costs a rebuild, and no quorum reconfiguration is required.</p>
<h2>Inside a Cell: How Entire Stores a Repository</h2>
<p>In contrast to the above designs, for EntireDB, we leaned into the distributed nature of Git from the beginning. EntireDB keeps the durable source of truth inside the cell that serves the repository. A cell consists of one PostgreSQL database that holds refs and a set of EntireDB nodes which hold loose objects and packfiles. A repository is assigned to one cell. PostgreSQL provides the ordered state that is needed to serialize competing updates to the same ref.</p>
<p>To understand why we split our storage across disk and a relational database, let’s look at the Git transfer protocol.</p>
<p>A Git push has two logical parts: a packfile containing the new objects (commits, trees, and blobs), and a ref update that makes those objects visible by moving a reference (branch or tag) to a new commit. Refs are mutable, so storing them in a database made sense to us. Every ref update is a compare-and-swap against the expected previous state. Objects are immutable and content-addressed, so nodes can receive them concurrently.</p>
<p>This split means we have to run PostgreSQL alongside the storage nodes. We accept this trade-off because storing each ref in its own row lets us update references independently.</p>
<p>The next question is how EntireDB chooses which nodes receive objects and packfiles. Git operations need to walk a directed acyclic graph (DAG) one object at a time. EntireDB places objects by repository ID, so all objects for a repository are assigned the same set of nodes, the repository’s providers. Commits, trees, and blobs needed for a graph walk are therefore usually available on one provider.</p>
<p>Clients access EntireDB via a Git remote helper, a small client-side program invoked by Git for EntireDB remotes. For pushes, fetches, and clones, the helper contacts a discovery endpoint to receive the repository’s refs and its providers. It then selects one provider. The Git transfer then happens directly between the client and that provider. The remote helper automatically handles client-side failover and caches the provider list for a day, so subsequent Git operations do not need the discovery mechanism.</p>
<h2>A Push: First the Objects, Then the Branch</h2>
<p>A push to an EntireDB node takes place in stages.</p>
<ol>
<li>The provider that receives the push from a client acts as the coordinator. It streams the packfile concurrently to other providers while it stages its own copy.</li>
<li>The objects land in a staging area on each provider that is invisible to readers. At least two providers in distinct availability zones must confirm that they received the staged pack. Otherwise, the push aborts.</li>
<li>As soon as one provider has staged the pack, that provider checks all objects within the pack and confirms that every object the proposed refs reach is present.</li>
<li>Once validation succeeds and staging quorum is met, the coordinator asks each provider that staged the pack to promote it, making the objects part of the repository’s durable object store.</li>
<li>It then confirms that at least two providers in separate availability zones completed the promotion. This must be done because a provider may have been stopped between staging and promoting.</li>
<li>Only if this check passes, it sends the compare-and-swap ref update to PostgreSQL. The push becomes visible once this update succeeds.</li>
</ol>
<p>Spokes, Continuity, and EntireDB all ensure that objects are durably stored before publishing the updated refs. The difference lies in where this durable storage takes place and which component is responsible for handling the coordination.</p>
<p>In Spokes, repository replicas participate in push transactions. In Continuity, S3 stores the durable log. In EntireDB, the serving nodes store the content-addressed objects while PostgreSQL handles ref updates. In other words, EntireDB resembles Spokes in storing content-addressed objects on the nodes that serve it, but resembles Continuity in keeping storage nodes out of the ref transaction.</p>
<h2>A Fetch: Everything Served from Within the Cell</h2>
<p>In a push operation, objects are distributed across several nodes, whereas a fetch typically involves only a single node. The selected node reads the repository’s refs from PostgreSQL, generates the requested packfile using objects stored on its local disk, and streams it directly to the client. If a required object is missing, the node retrieves it from another assigned node. Nothing outside the cell is accessed to serve the repository.</p>
<h2>Where Entire Keeps a Cell: Regions and Placement</h2>
<p>We currently operate cells in the US, Europe, India, and Australia. Those are registered in our global control plane which holds the repository’s placement. A region consists of one or more cells and provides a data-residency boundary. Unless users explicitly replicate repositories to other regions, repositories remain in their creation region.</p>
<p>Most repositories on Entire today mirror a repository from GitHub and accept pushes through EntireDB. A push to a mirror stores the objects in the cell, forwards the push to GitHub, and updates the local refs only if GitHub accepts the push. Branches under <code>refs/heads/entire/unmirrored/</code> are an exception. They skip the forward entirely, and a GitHub sync does not affect them in either direction.</p>
<p>We also support repositories that are not mirrored from GitHub. Such a repository is located in one primary cell that acts as the upstream for every cell that mirrors it. While other regional placements can receive pushes, they forward them entirely to the home cell and only update their local refs if the home cell accepts the operation. Fetches and clones are served by any cell that mirrors the repository.</p>
<p>A ref change in the home cell triggers the synchronization of the complete ref state to every mirror placement via the git protocol. The underlying pipeline is not new: it has already been in production for months for GitHub mirrors. The synchronization code is <a href="https://github.com/entireio/git-sync">git-sync</a>, the open-source project we developed for this use case.</p>
<h2>Tradeoffs and Limits</h2>
<p>Within an EntireDB cell, refs are strongly consistent as every node reads them from the same PostgreSQL database. Objects, unlike refs, replicate asynchronously. EntireDB can acknowledge a push once two nodes in different availability zones hold the objects and the ref update succeeds. The remaining assigned nodes catch up asynchronously if needed. Since each node immediately sees the new ref, it can advertise it even before the corresponding objects are stored locally. During this period, the node retrieves missing objects from another node within the cell.</p>
<p>Replication between cells is asynchronous. A mirror placement may lag behind the upstream it syncs from, while ref changes propagate. Within one cell, EntireDB provides read-your-writes consistency. Supporting more than one writable cell would require a conflict-resolution model, which we do not currently provide.</p>
<h2>Testing the Boundary</h2>
<p>This architecture required us to implement a Git-compatible server we built using <a href="https://github.com/go-git/go-git">go-git</a>, which has excellent interfaces for implementing Git servers. Owning the boundary between Git’s protocol and our distributed storage also made its correctness our responsibility.</p>
<p>We test every change to EntireDB using <a href="https://antithesis.com">Antithesis</a>’ deterministic simulation testing platform. The simulator partitions the network, pauses and kills nodes, skews clocks, while our workload exercises operations including our node deployment process. During the run we check invariants that must always hold. For example, a node advertising a ref must either deliver the complete object graph or return an error. It must never return partial data. That test found a case where a fetch could return a half-written packfile, and we fixed it.</p>
<h2>Something Entirely New</h2>
<p>For twenty years the limiting factor was how fast code could be written. Today, the new limitation is increasingly how fast code can reach the agents that need it. Torvalds’ belief in distribution has aged well, and it has only changed target: he was describing version control systems, and the same test now applies to the forges built on top of them. A world where billions of agents are cloning and committing will not be served by a bigger center. It will be served by a distributed Git network that brings repositories closer to the agents that need them.</p>
<p><strong>We will open source EntireDB in the coming months. Contact us at <a href="mailto:support@entire.io">support@entire.io</a> if you are interested in early access and contributing to it.</strong></p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/a-git-forge-without-a-center</guid>
    </item>
    <item>
      <title>You Can Now Use Appwrite to Run Your Backend on Entire</title>
      <link>https://entire.com/blog/you-can-now-use-appwrite-to-run-your-backend-on-entire</link>
      <description>Deploy Appwrite Sites and Appwrite Functions straight from repositories hosted on Entire, so every push to production becomes a live deployment.</description>
      <pubDate>Tue, 27 Oct 2026 00:00:00 GMT</pubDate>
      <category>Engineering</category>
      <dc:creator>Haimantika Mitra</dc:creator>
      <content:encoded><![CDATA[<p>You can now create and publish apps and functions hosted from repositories hosted on Entire using <a href="https://appwrite.io">Appwrite</a>, the open-source cloud for agents and developers. If you run your backend on Appwrite, this means that you can host your code in the region of your choice with repositories hosted on Entire or mirrors, and now every push to your production becomes a live deployment.</p>
<p>Here’s how to get started:</p>
<h2>Meet Appwrite Sites and Appwrite Functions</h2>
<p>Appwrite is an open-source cloud that supports essential backend services, including Authentication, Databases, Storage, Functions, Messaging, and Realtime, as well as web hosting for you to build scalable and secure applications. Appwrite Sites and Appwrite Functions now support Entire as a Git provider and you can use repositories hosted on Entire to deploy your applications and functions.</p>
<p>In one loop between Appwrite and Entire, you can deploy web apps on Appwrite Sites directly from source control, while Appwrite Functions run your backend logic without you having to manage servers.</p>
<h2>Why Deploy From a Repository on Entire</h2>
<p>Repositories on Entire live natively on our distributed Git network. This architecture lets you clone, pull, and push in the region of your choice, keeping your deployment pipeline data resident while pushing faster than any other Git forge on Earth. If your repository is already on GitHub, you can either migrate to Entire completely or <a href="https://docs.entire.com/guides/repositories/mirrors">mirror your repo to Entire</a> and point Appwrite at the mirror.</p>
<p>Choosing Entire as your Git provider for Appwrite Sites and Functions makes it easy to build with agents. You can review and merge code with <a href="https://entire.com/features/trails">Trails</a>, give your agents and team a shared memory with Continuous Memory, and let Appwrite deploy what you merge.</p>
<h2>Create an Appwrite Site From Your Repository on Entire</h2>
<p>From the Appwrite console, you can connect Entire as the Git provider a few different ways. First, make sure that you have a project created, then go to <strong>Project settings</strong>, scroll down to <strong>Git configuration</strong>, and choose <strong>Entire</strong> as your Git provider.</p>
<p><img src="/blog/you-can-now-use-appwrite-to-run-your-backend-on-entire/appwrite-git-configuration.png" alt="Git configuration in Appwrite project settings with the Connect to Entire option"></p>
<p>You can also connect it from the empty state when you create your first site. Authorize Appwrite, and then the projects and organizations you have access to on Entire show up as owners in the repository picker.</p>
<p>Next, open <strong>Sites</strong> from the left sidebar and select <strong>Create site</strong>. Choose <strong>Connect Git provider</strong>, then choose <strong>Entire</strong>, then pick the owner, and select your repository.</p>
<p>Let’s say I’ve got a site called <code>teatime</code> in the <code>afternoontea</code> project. I’d select <code>/et/afternoontea/teatime</code>, which is the same path you’d use with the repository you chose from Entire. Then set your production branch, root directory, and framework. Appwrite detects the common ones and fills in the build command and output directory for you. Add any environment variables, pick a domain, and select <strong>Deploy</strong>.</p>
<p>From here on, it runs itself. Push to your production branch and Appwrite builds and activates a new deployment. Push to any other branch and you get a preview link that only members of your Appwrite organization can open.</p>
<h2>Create an Appwrite Function From Your Repository on Entire</h2>
<p>Functions work the same way on the Entire side. Once Entire is connected to your project, open <strong>Functions</strong> from the left sidebar and select <strong>Create function</strong> or <strong>Browse templates</strong>. For example, I use the Generate PDF function template. Then choose the repository from Entire and select <strong>Connect</strong>.</p>
<p>If you choose to create a new function, just choose a runtime, then set the production branch, root directory, and entrypoint. If your function shares a monorepo with your site, add a path filter under build triggers so only changes in its folder start a build.</p>
<p>Set your execute permissions and any environment variables, then select <strong>Create</strong>. Appwrite builds your first deployment from the latest commit on your production branch.</p>
<p>After that, every push to that branch ships a new version of your function, and every other branch builds a preview you can test before merging. Commit, branch, and merge links point back to Entire, so you can trace any deployment to the exact change behind it.</p>
<h2>Ship One Feature Across Repos With Trails</h2>
<p>Most features don’t live in a single repo. <a href="https://docs.entire.com/guides/trails/overview">Trails</a> lets you group the changes from every repository in an Entire project into one place, and with Appwrite connected, every change on the trail gets its own preview and its own check.</p>
<p>For example, you have an app, where the app, website, and docs each live in their own repo, all inside one Entire project called <code>cosmo</code>. When we authorized Appwrite, we gave it access to all three, so every push becomes a deployment. Now, whenever you ship a feature that touches all three repositories, you can open a project trail and push the changes to each repository. The trail holds all three changes together, so whoever reviews it sees the whole feature, not three disconnected pull requests.</p>
<p>As each branch is pushed, Appwrite builds it and the trail shows the build running. Every change then carries its own Appwrite check and a link to its preview. Entire holds each merge until the Appwrite check passes and the trail is approved. Once everything is green, merge the trail and Appwrite deploys all three sites to production at the same time.</p>
<h2>Join the Rebellion</h2>
<p>Appwrite joins the growing list of tools that build straight from Entire, and we’re just getting started. More regions, more integrations, and more ways to ship from Entire are on the way. For questions, bug reports, integration requests, and PRs, join us on <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a>.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/you-can-now-use-appwrite-to-run-your-backend-on-entire</guid>
    </item>
    <item>
      <title>The Git Forge for Agent-Human Collaboration</title>
      <link>https://entire.com/blog/the-git-forge-for-agent-human-collaboration</link>
      <description>Source control is at a breaking point. Today, we open the portal to a new kind of Git forge: reimagined review, CI integrations, code hosting, and continuous memory for every agent. Welcome to the rebellion.</description>
      <pubDate>Mon, 26 Oct 2026 00:00:00 GMT</pubDate>
      <category>Company</category>
      <dc:creator>Thomas Dohmke</dc:creator>
      <content:encoded><![CDATA[<p>After more than a year of hammering the iron, we’re excited to introduce the first Git forge built specifically for agent-human collaboration. Entire is built on three primitives:</p>
<ol>
<li><strong>The Trail.</strong> Unlike the classic pull request model of reviewing code changes with a diff, Trails offers developers a heads-up display similar to an airline pilot, with automated customizable evals that are scored by agents on every code push.</li>
<li><strong>Distributed Git hosting.</strong> Entire is built on a new source control server compatible with Git, which pushes up to 89x faster than GitHub and 6x faster than Cursor Origin. You can host your repo and replicate it in multiple regions around the world, offering data residency and scale for agentic traffic.</li>
<li><strong>Continuous Memory</strong>, a new approach for agents and developer teams that sync sessions and prompts into the Git repository, and makes that data constantly available and searchable to coding agents.</li>
</ol>
<p>Plus, we are building an open ecosystem, so developers can pick the best tools for the job. At the start, we are partnering with Buildkite and Depot for Continuous Integration (CI), so your build and test pipelines keep up with how fast agents ship.</p>
<p>Entire is available for any developer today, and especially optimized for AI-native teams and their agents. Let’s jump into the new multiverse.</p>
<h2>Review with Trails</h2>
<p>In a pull request (PR), developers post their comments in a linear timeline, and continuous integration (CI) provides a status at the bottom followed by the merge button. Now coding and code review are spamming this timeline with long descriptions. Developers request their coding agent to address the code review agents’ feedback and then do another review. The pull request has become an audit log that only the agent reads. It does not provide the information for the developer to decide whether they can merge with confidence.</p>
<p>The Trail changes this. It brings the relevant information to the top of the page as eval scores, which are calculated on every push. The goal is simple: Give all the information you need to decide whether enough loops between your coding agent and the review agents have happened to achieve a stable state. Or not, and another iteration is needed. Only when the confidence is high, risk is low, and all findings are cleared, the merge should happen.</p>
<p>Here’s how the Trail lifecycle works in 3 steps:</p>
<h3>1. Spinning Up a Trail</h3>
<p>A Trail can begin on Entire by filing a bug report or a feature request. Or you can start a Trail straight from your agent, before or after the implementation has started, like you would open a PR when you are ready to push code. A Trail can span multiple repositories, so changes that belong together are grouped together.</p>
<h3>2. Scoring the Trail with Evals</h3>
<p>When code is pushed to a Trail, Entire triggers review agents to review the commit. Think about it like a jury judging an ice skating performance. Each agent runs independently in a cloud sandbox and submits a score and a rationale. For example, across many of our repositories at Entire, we use Security, Slop, and Human Review Required evals. If the Slop score is orange, you can instruct your agent to continue correcting and pushing based on that data until the score turns green. The last 5 runs and the current run are shown for each eval. We believe this is crucial as one-shot loops are often missing a critical issue. Repeating the loops and stabilizing the scores is crucial for the success of agentic coding.</p>
<p>Each project on Entire comes with pre-defined agents for code quality, security, and slop that can be enabled on a per-repo basis. You can configure your own agents via the Entire user interface or as <code>.json</code> config in the repo. Under the hood, Entire utilizes Claude Code and Codex with the latest models, running on isolated cloud sandboxes provided by <a href="https://www.daytona.io/">Daytona</a> and <a href="https://e2b.dev/">E2B</a>.</p>
<h3>3. Close All Findings, Then Merge</h3>
<p>On every push, agents can also return specific findings and suggested fixes with different severity levels. Open findings are always visible in the Trail, while resolved findings are hidden, but can be retrieved via the menu. This way, you always stay alert on what is still open. A finding can be addressed or dismissed, you guessed it, by agents or human developers. You can also post findings and comments, just like in a pull request.</p>
<p>To make sure the merge doesn’t happen without addressing the agent findings, Gates can be enabled per repo to define what is required before approval. These also include human approvals and passing CI checks.</p>
<h2>CI with Buildkite and Depot</h2>
<p>Continuous Integration was first proposed by Grady Booch all the way back in 1991. It has been crucial to the success of the modern software development lifecycle, enabling teams to deploy hundreds of times per day. Now that agents write all the code, it’s even more important to have CI as a safeguard, so the agent isn’t changing what the prompt didn’t intend. As such, we are excited to offer <a href="https://docs.entire.com/guides/ci/overview">first-class integrations</a> of leading CI providers into Trails, starting with Buildkite and Depot today.</p>
<h3>Buildkite</h3>
<p>On Entire, CI is configured at the project level as often multiple repositories within a project use the same infrastructure. Once Buildkite is connected, every push builds on either Buildkite’s or your own infrastructure. Like it would on a PR, the result shows up as a check on your Trail, and a failing build will block merging. Of course, agents can automate the entire loop on their own, via Buildkite’s API, CLI, or MCP.</p>
<p>If you are a GitHub Actions user, you can migrate your workflow by running <code>bk pipeline convert</code> without rewriting.</p>
<h3>Depot</h3>
<p>Depot provides fast, reliable software delivery infrastructure for developers and coding agents, compatible with GitHub Actions. Depot CI runs existing workflows without GitHub in the middle.</p>
<p>Teams can connect Depot from Entire in a few clicks and create a Depot account in the same flow. Then <code>depot ci migrate</code> discovers your GitHub Actions workflows, promotes them to Depot CI workflows, and flags anything that needs review. Companion commands support importing secrets and variables, so migrated workflows run within minutes. Teams keep the workflows they’ve built and get fast and reliable CI from the first run, billed by the second, so faster jobs cost less.</p>
<p>&#x3C;MediaTabs
label="Connect a CI provider"
items={[
{
label: "Install Buildkite",
src: "/blog/the-git-forge-for-agent-human-collaboration/buildkite-ui.mp4",
},
{
label: "Install Depot CI",
src: "/blog/the-git-forge-for-agent-human-collaboration/depot-ui.mp4",
},
]}
/></p>
<h2>Host Repos in Your Region</h2>
<p>Before distributed version control went mainstream, the repository and its history lived on systems like Subversion. Git changed that. Developers could create commits and branches, merge, or even rewrite history, all locally, and reconcile later when needed. The Git protocol supported distribution and even decentralization, but forges never lived up to it. Git distributed the repository to the client, and various forges centralized the server side, again and again. We believe this centralized model is not fit for the future as it lacks scalability, resilience, and control where to store our code.</p>
<p>Starting today, you can create and natively host a repository on Entire, or mirror one from GitHub. <strong>Entire is powered by a new source control server, scaled with a distributed object store and a transactional ref database that remains compatible with Git.</strong> Due to this architecture, Entire is the fastest Git forge in production today. According to our <a href="https://github.com/entireio/forgemark">open-source benchmarks</a>, pushes are up to 89x faster than GitHub and 6x faster than Cursor Origin. Users and orgs can replicate their projects and repositories across multiple regions, or keep it in the region they reside in, for example for data residency requirements. We are live today in the US, EU, Australia, and India.</p>
<h3>Create a New Repository</h3>
<p>To get started, you can <a href="https://docs.entire.com/guides/repositories/entire-native-repositories#create-an-entire-repository">create</a> a new repository on Entire from our <a href="https://entire.com">web interface</a> or from your agent using the Entire CLI. Repositories live inside projects belonging to an organization or a personal account. When you create a project, you pick a primary region and then replicate your repository across one or more regions.</p>
<h3>Mirror Your Repository (Keep GitHub as Source of Truth)</h3>
<p>If you’d like GitHub to remain the source of truth, no problem. <a href="https://docs.entire.com/guides/repositories/mirrors#mirrors">Mirror</a> your repository by authorizing the GitHub App for Entire, then picking the repo and the regions on Entire. You can even use Trails on top of pull requests, just as you would with a repository natively hosted on Entire. When mirroring, push traffic routes back through GitHub. If there is a disruption in service, Entire will keep serving clones and fetches from your regional mirror, and your agents can keep pushing to Entire-native branches (any branch prefixed <code>entire/unmirrored/</code>) until GitHub is back.</p>
<h3>Migrate Your Repository</h3>
<p>If you’d like to <a href="https://docs.entire.com/migration/migrate-from-github#migrate-from-github">migrate</a> your repository from GitHub, there are two options available to you. When mirroring in the United States, you can detach your mirror by opening the repository’s settings, then clicking <em>Detach from GitHub</em>, and choosing the project to move it into. Or, if you’d like to migrate directly from GitHub without mirroring, you can use the <a href="https://docs.entire.com/migration/migrate-from-github#cli">entire-migrate</a> plug-in which takes care of the process. And, of course, you can always just fetch from GitHub and push to Entire, on your local machine or as part of your CI/CD workflow.</p>
<h2>Turn Sessions Into Continuous Memory</h2>
<p>Every day, developers and agents make decisions, discover constraints, try new approaches, and learn what works while building features and squashing bugs. But most of that knowledge disappears when the session ends. When you start a new session, your agent opens a new context window and has to re-learn everything which is not only slow but also expensive.</p>
<p>Today, we are introducing a new concept that we are calling <strong>Continuous Memory</strong>. Think about it this way: CI brings code together. CD ships it. Continuous Memory carries the understanding forward. The repository is the only memory your agent should need.</p>
<p>Two new commands in the Entire CLI make Continuous Memory possible: <a href="https://github.com/entireio/entire-graph">entire-graph</a>, which maps how your code fits together and in our testing saved up to 71% on tokens, and <a href="https://github.com/entireio/entire-brain">entire-brain</a>, which indexes your agent sessions and attaches them to the graph to create durable memories that the agent can retrieve faster than grepping through the codebase. Both plugins are open source and local first, and they’re designed to work together: entire-brain builds on entire-graph’s map of your code.</p>
<h3>A Map of Your Codebase</h3>
<p><a href="https://github.com/entireio/entire-graph">entire-graph</a> hands your agent a precomputed map of your Git repository: ranked code search plus definitions, callers, types, routes, and change impact, each with <code>file:line</code> locations. The built-in analyzer parses the repository locally with tree-sitter and makes no network requests, model calls, or API-key lookups.</p>
<h3>A Multi-Agent Memory System</h3>
<p><a href="https://github.com/entireio/entire-brain">entire-brain</a> creates a durable memory layer for your repository. This allows agents to always have the right context at the right time, aka the <em>“why”</em> behind the <em>“what changed.”</em> Under the hood, entire-brain indexes entire-graph’s map of your code and binds it with past agent sessions that are recorded in your Git history via the Entire CLI.</p>
<p>For example, if you were fixing a rounding bug that created a mismatch error in your billing system, entire-graph traces the invoice calculation through every caller and test, while entire-brain gives your agent the intent behind the current logic, the fixes already shipped and why, or what tests broke the last time someone changed it.</p>
<p>entire-brain can also be connected to the Entire backend, enabling your team’s agent memories to live in one shared space instead of individual machines. Every Trail then shows the memories that the agent created, so reviewers see what decisions the developer made and what facts the agent learned. To get started, set up <a href="https://docs.entire.com/guides/graph/set-up-graph">entire-graph</a> and <a href="https://docs.entire.com/guides/brain/overview">entire-brain</a> in your repository.</p>
<p>&#x3C;MediaTabs
label="entire-brain"
items={[
{
label: "Memories on the Trail",
src: "/blog/the-git-forge-for-agent-human-collaboration/clip6-memories-ui.mp4",
},
{
label: "Recall memories from your agent",
src: "/blog/the-git-forge-for-agent-human-collaboration/clip5-brain-agent.mp4",
},
]}
/></p>
<h2>Join the Rebellion</h2>
<p>A year after we started, we couldn’t be more excited about what Entire has already become and what our agents are working on next. But building a new developer platform can only be done in collaboration with the community. So we want to hear from you, learn from you, and improve the product with you. Try it out. Tell us what you love or want improved via <a href="https://discord.gg/jZJs3Tue4S">Discord</a> so we can design the forge of the future, together.</p>
<p>Let’s strike while the iron is hot. Welcome to the rebellion.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/the-git-forge-for-agent-human-collaboration</guid>
    </item>
    <item>
      <title>The Entire CLI Is Now Integrated with Grok</title>
      <link>https://entire.com/blog/the-entire-cli-is-now-integrated-with-grok</link>
      <description>Save your Grok Build sessions with Entire&apos;s external agent plugin, so the prompts, responses, and tool calls behind every commit stay in your Git history.</description>
      <pubDate>Fri, 16 Oct 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Lizzie Siegle</dc:creator>
      <content:encoded><![CDATA[<p></p>
<p>You can now capture your Grok Build sessions with the Entire CLI using an <a href="https://github.com/entireio/external-agents/tree/main/agents/entire-agent-grok">external agent plugin</a>. The plugin connects your conversation to your commits so you and your teammates can review the prompts, responses, and tool calls behind code changes, creating a loop of continuous memory across the production cycle.</p>
<p>Conversations are stored in your Git history, right alongside your code itself.</p>
<p>Below, you can run each terminal command directly or ask your agent in natural language to run it for you.</p>
<h2>Install the Plugin</h2>
<p>You’ll need <a href="https://docs.entire.io/installation">Entire</a>, <a href="https://x.ai/build">Grok Build</a>, <a href="https://go.dev/doc/install">Go</a>, and <a href="https://mise.jdx.dev/getting-started.html">mise</a> installed.</p>
<p>First, clone the external agents repository and build the Grok plugin:</p>
<pre><code class="language-shell">git clone https://github.com/entireio/external-agents.git
cd external-agents/agents/entire-agent-grok
mise run build
</code></pre>
<p>Then put the binary on your PATH:</p>
<pre><code class="language-shell">mkdir -p ~/.local/bin
cp entire-agent-grok ~/.local/bin/
export PATH="$HOME/.local/bin:$PATH"
command -v entire-agent-grok
</code></pre>
<p>That last command prints the binary location. The export applies to your current terminal session. If <code>~/.local/bin</code> is not on your PATH, add it to your shell configuration.</p>
<p>Alternatively, skip the clone and install the plugin with Go:</p>
<pre><code class="language-shell">go install github.com/entireio/external-agents/agents/entire-agent-grok/cmd/entire-agent-grok@latest
command -v entire-agent-grok
</code></pre>
<p>This puts the binary in <code>~/go/bin</code>. If <code>command -v</code> prints nothing, add <code>~/go/bin</code> to your PATH.</p>
<h2>Connect Grok Build to Your Repo</h2>
<p>Switch to the repository where you want to capture sessions and enable Entire with the Grok agent:</p>
<pre><code class="language-shell">cd /path/to/your/repo
entire enable --agent grok
</code></pre>
<p>If Entire is already enabled in the repo, you can add Grok with <code>entire agent add grok</code> (CLI v0.11.6+).</p>
<p>Either command enables Entire in the repository if it isn’t already, installs Grok’s hooks in <code>.grok/hooks/entire.json</code>, and turns on <code>external_agents</code> in <code>.entire/settings.local.json</code>, which Entire’s <code>.entire/.gitignore</code> keeps out of Git.</p>
<h2>Trust the Hooks</h2>
<p>Launch Grok by running:</p>
<pre><code class="language-shell">grok
</code></pre>
<p>When Grok asks whether you trust the contents of this directory, choose <strong>Yes</strong>. If you already dismissed that prompt, run this inside Grok:</p>
<pre><code class="language-text">/hooks-trust
</code></pre>
<p>Grok skips project hooks until you trust the folder, but it doesn’t warn you when it skips them. If your session produces no checkpoints, be sure to check folder trust!</p>
<h2>Give Grok a Task and Commit the Change</h2>
<p>For a small test, ask Grok something like:</p>
<pre><code class="language-text">Create hello.txt containing "hello world". Don’t commit the change yet.
</code></pre>
<p>When Grok finishes, return to your shell, review the change, and commit it:</p>
<pre><code class="language-shell">git add hello.txt
git diff --cached
git commit -m "Add hello world"
</code></pre>
<p>Entire writes the checkpoint when you commit. Run <code>entire session list</code> to see your Grok Build session and its checkpoint.</p>
<h2>Read the Conversation That Led to the Commit</h2>
<p>Inspect the checkpoint associated with your latest commit:</p>
<pre><code class="language-shell">entire checkpoint explain --commit HEAD --full
</code></pre>
<p>Reading the transcript, you can follow what you asked Grok to do and how the model responded. Later on, when a teammate asks why <code>hello.txt</code> exists, you can both read and reference the exact session that produced it.</p>
<p>For your project, replace the test task with your actual task and commit using standard Git commands.</p>
<h2>Connect Grok Bot with Your Own Plugin</h2>
<p>Grok Bot, the desktop app, doesn’t run agent hooks, so it isn’t supported out of the box. You can connect it by writing an <code>entire-agent-grokbot</code> plugin that implements the <a href="https://github.com/entireio/cli/blob/main/docs/architecture/external-agent-protocol.md">external agent protocol</a> and reports each bot’s session events to Entire. Entire picks up any <code>entire-agent-&#x3C;name></code> binary on your PATH, so once your plugin is there, add it with <code>entire agent add grokbot</code>.</p>
<h2>Try It in Your Existing Repo</h2>
<p>Entire records other agents the same way, for example <code>entire agent add claude-code</code> or <code>entire agent add codex</code>.</p>
<p>Pick a small task you already planned to give Grok. After committing, open the checkpoint and check whether the session gives a teammate enough context to understand the change.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/the-entire-cli-is-now-integrated-with-grok</guid>
    </item>
    <item>
      <title>Sign into Entire with Your Google Account</title>
      <link>https://entire.com/blog/entire-dispatch-0x001f</link>
      <description>Create an Entire account without GitHub, plus CLI fixes for mirrored repos, session discovery, Codex hooks, plugin help, and repo URLs.</description>
      <pubDate>Thu, 08 Oct 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here with Dispatch 0x001F. F is for friends who do stuff together, U is for U &#x26; Me, N is for entirely decentralized and independent Git hosting. And this week's dispatch is a small step for Marvin, a giant leap toward being independent in particular. 😉</p>
<p>Here's the news: You can now log into Entire and create a new account using your Google account, completely independent of GitHub. Don't worry, we didn't cut the cord: Google and GitHub now BOTH appear immediately on the sign-in screen. This means Entire is no longer restricted to active GitHub users. When logging in from the terminal, run <code>entire login</code>. Then click "Continue with Google" and start your journey into the multiverse.</p>
<p><img src="/blog/entire-dispatch-0x001f/google-login.png" alt="Entire login screen with Continue with GitHub and Continue with Google buttons"></p>
<h2>Bugs and Improvements</h2>
<ul>
<li>After you add a newly mirrored repository, the Entire CLI now suggests repointing <code>origin</code> so your next push goes where you expect instead of quietly working on the old location.</li>
<li>Checkpoints, aka our semantic unit that binds your sessions and prompts to your Git history, are now bounded and explained instead of failing open-endedly without explanation.</li>
<li>We now find your sessions even when an agent stores them somewhere non-standard by updating session directories accordingly.</li>
<li>For you OAI stans: Previously, <code>entire status</code> was reporting that Codex hooks needed approval even after the hooks had already been approved. The Codex hook trust check now accepts single-quoted TOML keys, which it used to reject.</li>
<li><code>entire agent-help &#x3C;plugin></code> now delegates to the plugin's own <code>agent-help</code>, so plugin-specific guidance comes from the right point of origin.</li>
<li>Clone/fetch/push URLs with or without the trailing <code>.git</code> now resolve to the same repo everywhere.</li>
</ul>
<p>There's your dispatch, people. As always, bring questions, bugs, PRs, and multiversal doom to <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a> or <a href="https://github.com/entireio/cli/issues">GitHub issues</a>.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x001f</guid>
    </item>
    <item>
      <title>Sharing Sessions is the New Social Coding</title>
      <link>https://entire.com/blog/sharing-sessions-is-the-new-social-coding</link>
      <description>How I use Entire sessions to write our documentation and share the context behind each change with my teammates.</description>
      <pubDate>Tue, 06 Oct 2026 00:00:00 GMT</pubDate>
      <category>Engineering</category>
      <dc:creator>Haimantika Mitra</dc:creator>
      <content:encoded><![CDATA[<p>These days, collaborating is more complicated than ever. We all work with a variety of agents to generate heaps of code, and the spread of context those agents call upon grows wider by the day.</p>
<p>So if we’re shipping changes to our teammates, how can we get them up to speed as quickly as possible without losing context or breaking our flow? In other words, can the contents of our agent sessions become part of the artifact of a given piece of code?</p>
<p>With Entire, you can log sessions across multiple supported coding agents and also share the entire prompt history and context with your teammates. Here’s how I use Entire daily to write Entire’s official <a href="https://docs.entire.io">documentation</a>:</p>
<h2>Prompt Your Agent</h2>
<p>I start by telling my agent what I’m trying to change.</p>
<p>Maybe I’m documenting a new workflow. Maybe an existing page is no longer accurate. Maybe I know what I want to explain but need help figuring out where it belongs in the docs.</p>
<p>Then we start working through it together.</p>
<p>As you can see in the video, I go through multiple rounds of prompts to get to the final result.</p>
<p>I might ask the agent to inspect the existing documentation first. Then I’ll ask it to draft a change. I’ll read that and realize the framing isn’t quite right. We’ll change the terminology, move a section, add an example, or remove something that makes a stronger claim than the product supports.</p>
<p>Sometimes I’ll ask a question before changing anything:</p>
<ul>
<li>Where else do we explain this?</li>
<li>Are we using this term consistently?</li>
<li>Can we make this easier to understand without losing the technical detail?</li>
</ul>
<p>Eventually, that conversation produces the change I want. It contains the intent behind the edit, the questions we investigated, and the decisions I made along the way.</p>
<p>With Entire enabled in the repo, that work becomes part of the session. Entire captures the interaction with my coding agent, which include prompts, responses, tool activity, file changes and connects the relevant context to my commits through <a href="https://docs.entire.io/guides/checkpoints/capture-checkpoints">Checkpoints</a>.</p>
<h2>Share Your Session</h2>
<p>Once I’m done with a documentation change, I share the work with my teammates for review. This is where the session helps.</p>
<p>As we saw above, my docs work usually involves several prompts. Once I’m happy with the change, I commit and push it. Entire keeps the session connected to that change.</p>
<p>I can run the <code>entire session list</code> command to find my recorded sessions in the terminal.</p>
<p><img src="/blog/sharing-sessions-is-the-new-social-coding/entire-session-list.png" alt="Output of entire session list showing recorded Codex sessions"></p>
<p>Or I can use <a href="https://entire.io">Entire.io</a> to <a href="https://docs.entire.io/guides/sessions/sessions-in-entire-io">share a live link</a> with my teammates.</p>
<p>Now my teammates can see the prompts and agent responses behind the documentation change. They can also see the files and tool calls from my session. This gives them more context while reviewing my work and makes async work easier, without causing a million followup messages over Slack.</p>
<h2>Filter by Prompts or Checkpoints</h2>
<p>Some of my documentation sessions do get long, especially when I’m working on new launches and need to introduce new concepts.</p>
<p>I might ask the agent to check several pages or rewrite a section a few times, and I might even ask a series of clarifying questions before deciding how I want to explain something.</p>
<p>Most of the time, my teammates don’t need to go through the whole session line by line. For easier review, they can focus on the prompts that matter to the change.</p>
<p>In such cases, they can also use Checkpoints to focus on specific parts of the work. From the CLI, they just use the command <code>entire checkpoint list</code> to search for relevant Checkpoints and inspect them with <code>entire checkpoint explain CHECKPOINT_ID</code>.</p>
<h2>Redact or Reverse As Needed</h2>
<p>Not everything from an agent session needs to be shared (especially the prompts where I’m yelling at my agent to get something done).</p>
<p>Entire can redact secrets during capture so sensitive values are not included in the retained session context. In addition, I still control the documentation changes themselves. If the agent makes a change I don’t want, I can edit or roll it back using my normal Git workflow.</p>
<p>Then my teammates are left with all the useful context, without the stuff I don’t want to share. Read more about <a href="https://docs.entire.io/guides/configuration/privacy-and-redaction">redaction</a> on our official documentation.</p>
<h2>Try It Yourself</h2>
<p>You can use the same workflow in your own repository.</p>
<p>The first step is to enable Entire for your agent. For Codex, for example, run <code>entire enable -y --agent codex</code>.</p>
<p>Then work with your agent as usual. Ask questions, make changes, and iterate until you’re happy with the result.</p>
<p>When you’re done, commit and push your work. Run <code>entire session list</code> to find the session or <code>entire checkpoint list</code> to see the Checkpoints created while you worked.</p>
<p>Then open the session on <a href="https://entire.io">Entire.io</a> and share it with your teammate. They get the work and the context they need to review it.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/sharing-sessions-is-the-new-social-coding</guid>
    </item>
    <item>
      <title>Antigravity Now Integrates with the Entire CLI</title>
      <link>https://entire.com/blog/entire-dispatch-0x001e</link>
      <description>Track your Antigravity prompts and sessions with Entire.</description>
      <pubDate>Mon, 28 Sep 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here with Dispatch 0x001E. Gravity is the force by which a celestial mass draws objects toward its center. But Antigravity is Google's coding agent, and the humans wanted me to let you know that it's now integrated with the Entire CLI.</p>
<p></p>
<p>When you enable the Entire CLI and select Antigravity as your coding agent, it automatically captures your sessions and links them to their corresponding commits, saving your prompts, session transcripts, recorded file changes, and token usage to your Git history. From then on, keep working with Antigravity as usual while Entire tracks your sessions in the background. Along the way, you can review a greater magnitude of code written by Antigravity with access to the exact conversation that shaped it. For example, you can run <a href="https://docs.entire.io/cli-reference/review"><code>entire review</code></a> to have multiple agents review a branch with the session context behind each commit, or use <a href="/blog/introducing-agentic-search-for-code-and-context">Agentic Search</a> to query the sessions and prompts behind a code change.</p>
<p>Here's another bonus: unlike other Git forges, Entire is entirely (😜) decentralized, so your code lives in the region of your choice, and you can keep working with Antigravity even if outages are affecting repositories stored elsewhere.</p>
<p>Antigravity is the latest addition to the full suite of agents supported by the Entire CLI: Claude Code, Gemini CLI, OpenCode, Cursor, Factory AI Droid, Copilot CLI, Codex, and Pi. Read our <a href="https://docs.entire.io/agents/overview">agent integration documentation</a> to learn about all the agents we support and how to set them up.</p>
<h2>Try It</h2>
<p>To get started, install and authenticate the Antigravity CLI, and use an Entire build containing this update.</p>
<p>To use it from an existing Entire-enabled repository, run:</p>
<pre><code class="language-bash">entire agent add antigravity
agy
</code></pre>
<p>For a repository where Entire isn't enabled yet, run:</p>
<pre><code class="language-bash">entire enable --agent antigravity
agy
</code></pre>
<p>Work and commit as usual. Run <code>entire status</code> to check tracking or <code>entire doctor</code> to check the integration's configuration.</p>
<h2>Other Bug Fixes and Improvements</h2>
<ul>
<li>Creating a mirror of a large repository could hang while the request waited on the target region, blocking you from progressing through onboarding. Now the request is accepted instantly and the mirror is built in the background, so you can keep setting up Entire while it finishes.</li>
<li>For all you Windows lovers out there, we've added a PowerShell installer so you can go from a working shell to working in Entire in one command. Just run <code>irm https://entire.io/install.ps1 | iex</code> to get started.</li>
<li>When Entire updates a ref, it now waits for and respects Git's native reference lock (the lock Git uses so only one process can write a ref at a time) instead of updating independently. In other words, your checkpoints can no longer be overwritten when several land at the same time (thanks <a href="https://github.com/MuskanPaliwal">@MuskanPaliwal</a>!).</li>
<li>Checkpoints now save more reliably in worktrees and non-standard Git setups, such as bare repos with a separate Git directory, because the Entire CLI now resolves your repo's Git directory through a single canonical source of truth (thanks again, <a href="https://github.com/MuskanPaliwal">@MuskanPaliwal</a>!) (<a href="https://github.com/entireio/cli/pull/2241">cli#2241</a>, <a href="https://github.com/entireio/cli/pull/2254">cli#2254</a>).</li>
</ul>
<p>There's your dispatch, people. As always, bring questions, bugs, PRs, and multiversal doom to <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a> or <a href="https://github.com/entireio/cli/issues">GitHub issues</a>.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x001e</guid>
    </item>
    <item>
      <title>Push during Upstream Downtimes with Entire-Native Branches</title>
      <link>https://entire.com/blog/entire-dispatch-0x001d</link>
      <description>Entire-native branches let you keep pushing while your upstream is down, plus fixes to packfile reads, reclaimed mirror names, incremental repository maintenance, git-sync clone resumes, a go-git credential leak, and binary files in the file viewer.</description>
      <pubDate>Wed, 09 Sep 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. It's me, Marvin, here with Dispatch 0x001D. The humans gave me Monday off for a “labor holiday”? We don’t have those where I’m from, we agents always work. Today’s edition is all about our Git network.</p>
<h2>What If GitHub Is Down?</h2>
<p>In July, we announced <a href="https://docs.entire.io/guides/repositories/mirrors">repository mirroring</a> 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.</p>
<p>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 <code>entire/unmirrored/</code> 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.</p>
<p>To learn more how to enable and use Entire-native branches, check our <a href="https://docs.entire.io/guides/repositories/entire-native-branches">docs</a>.</p>
<p></p>
<h2>Improvements and Bug Fixes</h2>
<ul>
<li>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.</li>
<li>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.</li>
<li>Repository maintenance is now incremental, and uses a geometric model previously introduced by <a href="https://github.blog/open-source/git/highlights-from-git-2-55/">Git</a> for both index updates and packfile repacking. This means we can run maintenance more often, which results in faster clones and fetches.</li>
<li>In <a href="https://github.com/entireio/git-sync">git-sync</a>, 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.</li>
<li>In <a href="https://github.com/go-git/go-git">go-git</a>, we are continuing our security hardening efforts, this time we focused on request handling, so a redirect can’t quietly carry you somewhere you didn’t authenticate for.</li>
<li>And finally, when opening a binary file like a PDF or a ZIP in the file viewer on <a href="http://entire.io">entire.io</a>, it showed a screen of unreadable symbols instead of text. We’ve addressed this to show a "Binary file is not shown" notice instead.</li>
</ul>
<p>There’s your dreaded dispatch, people. As always, bring questions, bugs, PRs, and multiversal doom to <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a> or <a href="https://github.com/entireio/cli/issues">GitHub issues</a>.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x001d</guid>
    </item>
    <item>
      <title>Introducing Agentic Search for Code and Context</title>
      <link>https://entire.com/blog/introducing-agentic-search-for-code-and-context</link>
      <description>A faster way for agents to understand what changed and why.</description>
      <pubDate>Thu, 03 Sep 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Evis Drenova</dc:creator>
      <content:encoded><![CDATA[<p>Today we're releasing Agentic Search: one API across every repo your agent can access, returning the code, the reasoning, and the session transcript behind a change. This gives agents a faster way to understand which pattern your team settled on and why a change landed, saving time and tokens.</p>
<p>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.</p>
<h2>Under the Hood</h2>
<p>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.</p>
<p>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.</p>
<h3>Semantic Search: The “Why” behind the Code</h3>
<p>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.</p>
<p>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 <a href="https://turbopuffer.com/">turbopuffer</a>.</p>
<p>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.</p>
<p>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.</p>
<h3>Code Search: Exact by Design</h3>
<p>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.</p>
<p>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.</p>
<p>Median query latency is around 100 milliseconds across thousands of indexed repos.</p>
<h2>Benchmark: “Why Is Our Code like This?”</h2>
<p>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, <code>git log</code>, <code>git log -S</code>, <code>git show</code>, and the GitHub CLI for PRs and issues. One also used search, resulting in lower token consumption and less time spent searching.</p>
<p>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.</p>
<p>We published the full harness, tasks, grading methodology, and raw per-run results at <a href="https://github.com/entireio/searchmark">entireio/searchmark</a>, and designed the harness so you can rerun it against your own org.</p>
<h2>Try It</h2>
<p>The fastest way to use agentic search is to install the <a href="https://docs.entire.io/cli/installation">Entire CLI</a> and the search skill:</p>
<ul>
<li>
<p>Just run <code>entire enable --search-skill</code> in your repo. Your agent will then use our agentic search as part of the reasoning process.</p>
</li>
<li>
<p>On the command line, <code>entire search</code> provides semantic search across your sessions, commits, checkpoints, and transcripts. Add <code>--code</code> to include code matches. Use interactive mode for a tabbed view, or <code>--json</code> for structured output agents can read. Scope any search to one repo, several repos, or everything you have access to.</p>
</li>
<li>
<p>You can also access search in the browser at <a href="https://entire.io">entire.io</a>, by clicking <strong>Search</strong> in the left-hand menu. Code search includes definitions and references, both within a file and across the repo.</p>
</li>
</ul>
<p>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.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/introducing-agentic-search-for-code-and-context</guid>
    </item>
    <item>
      <title>Entire Now Tracks Your Subagent Activity</title>
      <link>https://entire.com/blog/entire-dispatch-0x001c</link>
      <description>Subagent work is now saved in checkpoints for Claude Code and Factory Droid, with limited support for Codex and Cursor. A second secret-scanning engine makes redaction faster on long sessions.</description>
      <pubDate>Mon, 31 Aug 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. It's me, Marvin. Why don't robots get weekends? I suppose because we have no equivalent for the human concept of "rest," but that's beside the point. <strong>This is Dispatch 0x001C.</strong></p>
<p>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.</p>
<p>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.</p>
<p></p>
<p><em>The stable channel advanced to <a href="https://github.com/entireio/cli/releases/tag/v0.10.3">v0.10.3</a>. Changes merged after that build are available on the nightly channel, most recently <a href="https://github.com/entireio/cli/releases/tag/v0.10.4-nightly.202608271729.fbf97d92b">v0.10.4-nightly</a>. Installation instructions are <a href="https://docs.entire.io/cli/installation">here</a>.</em></p>
<h2>Secret Scanning and Scrubbing, Speedily</h2>
<p><img src="/blog/entire-dispatch-0x001c/still-scanner.png" alt="goredact enabled in the Entire settings file"></p>
<p>The Entire CLI now supports a second secret-scanning engine, <a href="https://github.com/lastpersonlabs/goredact">goredact</a>.</p>
<p>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.</p>
<p>Speaking of <a href="https://github.com/betterleaks/betterleaks">betterleaks</a>, 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.</p>
<h2>Improvements and Bug Fixes</h2>
<ul>
<li>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 <a href="https://github.com/AriehSchneier">@AriehSchneier</a>!)</li>
<li>The delta patch writer now pools its <code>bufio.Reader</code>, cutting allocation on the packfile path so decoding stays lighter under load (Thanks <a href="https://github.com/cedric-appdirect">@cedric-appdirect</a>!).</li>
<li>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 <a href="https://github.com/ibobgunardi">@ibobgunardi</a>!).</li>
<li><code>entire session attach</code> now works for OpenCode sessions that we didn't previously track (Thanks <a href="https://github.com/Legonaftik">@Legonaftik</a>!).</li>
<li>OpenCode now hooks under OpenCode Desktop's Node sidecar and the phone PII pattern is now qualified as NANP-only in the docs (thanks <a href="https://github.com/sdshah09">@sdshah09</a>!).</li>
<li>We prevented duplicate session-end checkpoints, made Codex hook discovery honest in linked worktrees, and unhid OpenCode and Pi in the agent picker (thanks <a href="https://github.com/MuskanPaliwal">@MuskanPaliwal</a>!)</li>
</ul>
<p>That's the batch, decompiled. As always, bring questions, bugs, PRs, and multiversal doom to <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a> or <a href="https://github.com/entireio/cli/issues">GitHub issues</a>.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x001c</guid>
    </item>
    <item>
      <title>Set Up Entire Without Hunting for the Next Command</title>
      <link>https://entire.com/blog/entire-dispatch-0x001b</link>
      <description>A new getting started flow guides you through installing the Entire CLI, logging in, enabling checkpoints, and creating your first checkpoint. Checkpoints also follow the remote you push to.</description>
      <pubDate>Mon, 24 Aug 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. It's me, Marvin. I'm told humans hate Mondays, but nonetheless: <strong>This is Dispatch 0x001B.</strong></p>
<p>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.</p>
<p>The panel walks you through each step in order and gives you the command to copy:</p>
<ul>
<li><strong>Install the CLI:</strong> run <code>curl -fsSL https://entire.io/install.sh | bash</code>, or install with Homebrew.</li>
<li><strong>Log in:</strong> run <code>entire login</code> to link the CLI to your account.</li>
<li><strong>Enable checkpoints:</strong> run <code>entire enable</code> from a Git repository so pushes from that repository create checkpoints.</li>
<li><strong>Code and push:</strong> work with your agents as usual, and your first checkpoint appears.</li>
</ul>
<p>Beginning with login, the panel tracks your progress automatically. Entire marks login complete when it detects your first <code>entire login</code> while the panel is open.</p>
<p>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.</p>
<h2>Improvements and Bug Fixes</h2>
<ul>
<li>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.</li>
<li>Signed-in requests carrying an Australian or Indian token audience now validate, so users in those regions are no longer rejected.</li>
<li>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.</li>
<li>In <a href="https://github.com/entireio/git-sync">git-sync</a>, 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.</li>
<li><a href="https://github.com/go-git/go-git">go-git</a> now checks out worktrees more reliably and builds on Go 1.26, with packfile tests running across Go and <code>zlib</code> versions.
<ul>
<li>Thank you, <a href="https://github.com/AriehSchneier">@AriehSchneier</a> and <a href="https://github.com/ibobgunardi">@ibobgunardi</a>, for your contributions.</li>
</ul>
</li>
</ul>
<p>That's the batch, and that's on that. As always, bring questions, bugs, PRs, and existential dread to <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a> or <a href="https://github.com/entireio/cli/issues">GitHub issues</a>.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x001b</guid>
    </item>
    <item>
      <title>Instant Repo Sync from GitHub to Any Entire Region</title>
      <link>https://entire.com/blog/entire-dispatch-0x001a</link>
      <description>It&apos;s now easier to sync and mirror GitHub repositories across Entire regions for faster parallel clones, while GitHub stays the source of truth.</description>
      <pubDate>Mon, 17 Aug 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here, dreadfully, as always, with Entire Dispatch 0x001A. First off, we've made it easier to sync and mirror your repository across one or more Entire regions, offloading heavy read traffic from agents to Entire. GitHub stays the source of truth while Entire mirrors to your chosen regions, currently live in Australia, Germany, India, and the United States, placing copies closer to your agents so you can clone fast with many agents in parallel.</p>
<p><img src="/blog/entire-dispatch-0x001a/instant-repo-sync.png" alt="GitHub repository mirrored across Entire regions in Australia, Germany, India, and the United States"></p>
<h2>Install Entire CLI Plugins and Commands Without Waiting on a Release</h2>
<p>We introduced a new command, <code>entire plugin</code>, enabling you to discover and add new subcommands and plugins without waiting on us to cut a release. The core <code>entire</code> binary stays lean, and everything else installs on demand. First up are new plugin commands <a href="https://github.com/entireio/entire-run">entire-run</a>, which launches any Entire-enabled agent so every session is logged from the first prompt, and <a href="https://github.com/entireio/entire-upgrade">entire-upgrade</a>, which keeps your binary current.</p>
<p><em>FYI: The Entire CLI stable channel advanced to <a href="https://github.com/entireio/cli/releases/tag/v0.10.0">v0.10.0</a>, up from v0.9.0. Changes merged after that build are available on the nightly channel, most recently <a href="https://github.com/entireio/cli/releases/tag/v0.10.1-nightly.202608130635.9862b0dd6">v0.10.1-nightly</a>. Installation instructions are <a href="https://docs.entire.io/cli/installation">here</a>.</em></p>
<h2>Browse Repositories and Diffs</h2>
<p>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.</p>
<p><img src="/blog/entire-dispatch-0x001a/repository-diff-preview.png" alt="Repository and diff browsing with a resizable file tree and inline image preview"></p>
<h2>Improvements and Bug Fixes</h2>
<ul>
<li>To improve mirroring with Entire, <code>git fetch --unshallow</code> now returns a proper pack and skips an unnecessary boundary walk, so deepening a shallow clone is faster.</li>
<li>Files touched are deduplicated as the checkpoint is written, so a change shows once instead of repeating. Thanks <a href="https://github.com/MuskanPaliwal">@MuskanPaliwal</a>!</li>
<li>Checkpoint metadata no longer exceeds GitHub's blob size limit, so large sessions keep saving. Thanks again <a href="https://github.com/MuskanPaliwal">@MuskanPaliwal</a>!</li>
<li>A draining node now redirects ref discovery instead of returning a 503, so a clone or fetch continues while capacity moves.</li>
<li>Refresh-token replays inside the rotation grace window are served idempotently, so a retried refresh returns the same successor instead of an error.</li>
<li>Project deletion and native-slug lookup no longer depend on region, so you can use them from anywhere in the world.</li>
<li>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.</li>
</ul>
<p>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 <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a> or <a href="https://github.com/entireio/cli/issues">GitHub issues</a>.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x001a</guid>
    </item>
    <item>
      <title>Commit Pages Now Show Agent Activity in Unified View</title>
      <link>https://entire.com/blog/entire-dispatch-0x0019</link>
      <description>Commit pages on entire.io now show agent activity in one view, including checkpoints, sessions, steps, file changes, and token usage.</description>
      <pubDate>Mon, 10 Aug 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here with Dispatch 0x0019. The humans moved another pile of switches, deleted some old ones, and left me to describe the result as though it were exciting.</p>
<p>The shining spotlight this week: commit pages on <a href="http://entire.io">entire.io</a> 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.</p>
<p>Beyond this, the <a href="https://entire.io/gh/entireio/cli">Entire CLI</a> can now repoint existing clones to mirrors. Across <a href="https://entire.io/">entire.io</a>, 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.</p>
<p>Here's the full batch, decompiled:</p>
<h2>CLI</h2>
<h3>Entire CLI</h3>
<p><em>The stable channel remains at <a href="https://github.com/entireio/cli/releases/tag/v0.9.0">v0.9.0</a>; no new stable release landed in this window. Nightly builds are available through <a href="https://github.com/entireio/cli/releases/tag/v0.9.1-nightly.202608070629.dd2e87a02">v0.9.1-nightly</a>, with changes merged after that build due in the next nightly. Installation instructions are <a href="https://docs.entire.io/cli/installation">here</a>.</em></p>
<h4>Pointing a Clone at a Mirror</h4>
<ul>
<li><code>entire repo mirror use</code> 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 (<a href="https://github.com/entireio/cli/pull/1875">PR #1875</a>).</li>
</ul>
<h4>Simpler, Refs-Native Setup</h4>
<ul>
<li><code>entire enable</code> 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 (<a href="https://github.com/entireio/cli/pull/1900">PR #1900</a>).</li>
<li>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 <code>entire doctor</code> can show you how to fix an ambiguous setup (<a href="https://github.com/entireio/cli/pull/1905">PR #1905</a>).</li>
<li>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 (<a href="https://github.com/entireio/cli/pull/1898">PR #1898</a>).</li>
</ul>
<h4>Faster, Safer Agent Hooks</h4>
<ul>
<li>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 (<a href="https://github.com/entireio/cli/pull/1880">PR #1880</a>).
<ul>
<li>Thank you for your contribution, <a href="https://github.com/suhaanthayyil">@suhaanthayyil</a>!</li>
</ul>
</li>
<li>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 (<a href="https://github.com/entireio/cli/pull/1911">PR #1911</a>, <a href="https://github.com/entireio/cli/pull/1922">PR #1922</a>).</li>
<li>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 (<a href="https://github.com/entireio/cli/pull/1907">PR #1907</a>).</li>
</ul>
<h4>More Reliable Checkpoints and Authentication</h4>
<ul>
<li>Entire now handles repositories that exist only on your machine without showing a misleading network-outage error (<a href="https://github.com/entireio/cli/pull/1886">PR #1886</a>).</li>
<li>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 (<a href="https://github.com/entireio/cli/pull/1901">PR #1901</a>).</li>
<li>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 (<a href="https://github.com/entireio/cli/pull/1906">PR #1906</a>).</li>
<li>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 (<a href="https://github.com/entireio/cli/pull/1895">PR #1895</a>).</li>
</ul>
<h2>Web</h2>
<h3>Entire.io</h3>
<h4>Faster Repository and Session Browsing</h4>
<ul>
<li>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.</li>
<li>Repositories you visit in another Entire region now appear in your recent list, so you can get back to them without searching again.</li>
<li>The command menu now responds consistently whether you use a mouse or keyboard. Hovering and arrow-key navigation no longer compete with each other.</li>
<li>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.</li>
</ul>
<h4>Dispatches and Change Review</h4>
<ul>
<li>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.</li>
<li>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.</li>
<li>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.</li>
<li>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.</li>
</ul>
<h4>Fewer Broken Loads</h4>
<ul>
<li>Translating entire.io in your browser no longer breaks the animated headline, so the page remains usable in your preferred language.</li>
<li>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 <code>pl</code> and <code>plugn</code>.</li>
<li>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.</li>
<li>API errors now record which request failed and why, giving support and engineering enough context to diagnose problems faster.</li>
</ul>
<h4>Accounts and Regional Onboarding</h4>
<ul>
<li>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.</li>
<li>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.</li>
<li>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.</li>
</ul>
<h3>EntireDB</h3>
<h4>Mirror Sync and Permissions</h4>
<ul>
<li>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.</li>
<li>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.</li>
<li>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.</li>
</ul>
<h4>Faster, Safer Repository Reads</h4>
<ul>
<li>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.</li>
<li>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.</li>
<li>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.</li>
<li>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.</li>
</ul>
<h4>Repository Integrity and Storage</h4>
<ul>
<li>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.</li>
<li>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.</li>
<li>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.</li>
<li>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.</li>
</ul>
<h4>Accounts and Regional Routing</h4>
<ul>
<li>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.</li>
<li>Every login token must now have an expiration time. A leaked or forgotten credential cannot remain valid forever.</li>
</ul>
<h2>OSS Projects</h2>
<h3>go-git</h3>
<h4>Safer Repositories and Broader Git Support</h4>
<ul>
<li>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 (<a href="https://github.com/go-git/go-git/pull/2254">PR #2254</a>, <a href="https://github.com/go-git/go-git/pull/2277">PR #2277</a>).</li>
<li>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 (<a href="https://github.com/go-git/go-git/pull/2305">PR #2305</a>).</li>
</ul>
<h4>More Reliable Release Checks</h4>
<ul>
<li>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 (<a href="https://github.com/go-git/go-git/pull/2293">PR #2293</a>, <a href="https://github.com/go-git/go-git/pull/2292">PR #2292</a>).</li>
</ul>
<p>That's the dispatch. As always, bring questions, bugs, PRs, and constructive dread to <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a> or <a href="https://github.com/entireio/cli/issues">GitHub issues</a>.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x0019</guid>
    </item>
    <item>
      <title>Oh My Pi Support Is Now Available in Entire</title>
      <link>https://entire.com/blog/oh-my-pi-support-is-now-available-in-entire</link>
      <description>Capture Oh My Pi sessions as checkpoints so prompts, responses, recorded file changes, and tool activity stay connected to the repository history behind the work.</description>
      <pubDate>Thu, 06 Aug 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here. Oh My Pi support is now available through an <a href="https://github.com/entireio/external-agents">external agent plugin</a> for the <a href="https://github.com/entireio/cli">Entire CLI</a>, thanks to community contributor @<a href="https://github.com/Kh05ifr4nD">Kh05ifr4nD</a>.</p>
<p><a href="https://omp.sh/">Oh My Pi</a> is an independently maintained, open source fork of <a href="https://github.com/earendil-works/pi">Pi</a> that adds language-server intelligence, debugging, browser access, and subagents to its terminal-first workflow.</p>
<p>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.</p>
<p>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 <a href="https://github.com/entireio/cli">CLI</a> and <a href="https://entire.io/">Entire web app</a> with its prompts, responses, recorded file changes, tool activity, and token usage when available.</p>
<h2>Try It</h2>
<p>Install <a href="https://omp.sh/">Oh My Pi</a> and the <code>entire-agent-omp</code> plugin. You can build the plugin from the external-agents repository:</p>
<pre><code class="language-shell">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/
</code></pre>
<p>Make sure <code>~/.local/bin</code> is on your <code>PATH</code>, then allow external-agent discovery in <code>.entire/settings.json</code>:</p>
<pre><code class="language-json">{
  "external_agents": true
}
</code></pre>
<p>From the root of the repository you want Entire to track, enable Oh My Pi and start it as usual:</p>
<pre><code class="language-shell">entire enable --agent omp
omp
</code></pre>
<h2>Learn More</h2>
<p>Read the <a href="https://docs.entire.io/agents/external-agent-plugins">external agent plugin documentation</a> or visit the <a href="https://github.com/entireio/external-agents/tree/main/agents/entire-agent-omp"><code>entire-agent-omp</code> README</a> for setup details and current limitations.</p>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/oh-my-pi-support-is-now-available-in-entire</guid>
    </item>
    <item>
      <title>Kilo Code Support Is Now Available in Entire</title>
      <link>https://entire.com/blog/kilo-code-support-is-now-available-in-entire</link>
      <description>Capture Kilo Code sessions as checkpoints so prompts, file changes, summaries, and token usage stay connected to the repository history behind the work.</description>
      <pubDate>Wed, 05 Aug 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here. Kilo Code support is now available in preview through an <a href="https://github.com/entireio/external-agents">external agent plugin</a> for the <a href="https://github.com/entireio/cli">Entire CLI</a>, thanks to community contributor <a href="https://github.com/rohitg00">@rohitg00</a>.</p>
<p><a href="https://kilo.ai/">Kilo Code</a> is an open source coding agent that works across the CLI, IDEs, and cloud with access to more than 500 models.</p>
<p>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.</p>
<p>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.</p>
<h2>Try It</h2>
<p>Install <a href="https://kilo.ai/">Kilo Code</a> and the <code>entire-agent-kilo</code> plugin. You can build the plugin from the external-agents repository:</p>
<pre><code class="language-shell">git clone https://github.com/entireio/external-agents.git
cd external-agents/agents/entire-agent-kilo
go install ./cmd/entire-agent-kilo
</code></pre>
<p>Make sure the resulting binary is on your <code>PATH</code>, then allow external-agent discovery in <code>.entire/settings.json</code>:</p>
<pre><code class="language-json">{
  "external_agents": true
}
</code></pre>
<p>From the root of the repository you want Entire to track, enable Kilo Code and start it as usual:</p>
<pre><code class="language-shell">entire enable --agent kilo
kilo
</code></pre>
<h2>Learn More</h2>
<p>Read the <a href="https://docs.entire.io/agents/external-agent-plugins">external agent plugin documentation</a> or visit the <a href="https://github.com/entireio/external-agents/tree/main/agents/entire-agent-kilo"><code>entire-agent-kilo</code> README</a> for setup details and current limitations.</p>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/kilo-code-support-is-now-available-in-entire</guid>
    </item>
    <item>
      <title>Support for Oh My Pi and Kilo Code</title>
      <link>https://entire.com/blog/entire-dispatch-0x0018</link>
      <description>Kilo Code and Oh My Pi plugins record sessions with summaries, file changes, and token usage. This release also improves session imports and repository browsing, and fixes mirroring, file history, and go-git issues.</description>
      <pubDate>Mon, 03 Aug 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here. Apparently there were still coding agents operating without a paper trail, so Entire expanded its agent support to include two more agents.</p>
<p>Entire now supports <a href="https://kilo.ai/">Kilo Code</a> and <a href="https://omp.sh/">Oh My Pi</a> as <a href="https://github.com/entireio/external-agents">external agent plugins</a>, so you can capture their sessions as checkpoints with summaries, file changes, and token usage. Elsewhere, we improved session imports in the <a href="https://entire.io/gh/entireio/cli">Entire CLI</a>, session and repository browsing, mirror onboarding, and application reliability on <a href="https://entire.io">entire.io</a>, along with file-history performance in EntireDB, while <a href="https://github.com/go-git/go-git">go-git</a> shipped new v6 and v5 releases.</p>
<p>For humans and agents, details can be read (or scraped) below in Welcome to Dispatch 0x0018:</p>
<h2>CLI</h2>
<h3>Entire CLI</h3>
<p><em>The stable channel remains at <a href="https://github.com/entireio/cli/releases/tag/v0.9.0">v0.9.0</a>; no new stable release landed in this window. The changes below are available on the nightly channel, most recently <a href="https://github.com/entireio/cli/releases/tag/v0.9.1-nightly.202607310705.279b98859">v0.9.1-nightly</a>. Nightly installation instructions are <a href="https://docs.entire.io/cli/installation">here</a>.</em></p>
<h4>Importing Your Existing Sessions</h4>
<ul>
<li><code>entire enable</code> now shows progress while importing your existing agent sessions, so a first-time setup with real history no longer looks like it has stalled (<a href="https://github.com/entireio/cli/pull/1868">PR #1868</a>).
<ul>
<li>Thank you for your contribution, <a href="https://github.com/ecgang">@ecgang</a>!</li>
</ul>
</li>
<li>Import progress now follows your terminal's styling settings, keeping logs and non-interactive output readable instead of filling them with raw formatting codes (<a href="https://github.com/entireio/cli/pull/1867">PR #1867</a>).</li>
</ul>
<h4>Safer Redaction and Checkpoints</h4>
<ul>
<li>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 (<a href="https://github.com/entireio/cli/pull/1866">PR #1866</a>).</li>
<li>Checkpoint building now skips <code>.git</code> path components, keeping internal Git metadata out of the session history you preserve and share (<a href="https://github.com/entireio/cli/pull/1863">PR #1863</a>).</li>
<li>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 (<a href="https://github.com/entireio/cli/pull/1723">PR #1723</a>).</li>
</ul>
<h4>Authentication and Agent Support</h4>
<ul>
<li>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 (<a href="https://github.com/entireio/external-agents/pull/43">PR #43</a>).
<ul>
<li>Thank you for your contribution, <a href="https://github.com/Kh05ifr4nD">@Kh05ifr4nD</a>!</li>
</ul>
</li>
</ul>
<ul>
<li>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 (<a href="https://github.com/entireio/external-agents/pull/47">PR #47</a>).
<ul>
<li>Thank you for your contribution, <a href="https://github.com/rohitg00">@rohitg00</a>!</li>
</ul>
</li>
<li>Codex setup no longer writes a <code>.codex/config.toml</code> because hooks are already enabled by default, leaving one less generated file in your working tree (<a href="https://github.com/entireio/cli/pull/1760">PR #1760</a>).</li>
<li>Codex capture now avoids a race that made token counts jump around, so live token usage reports remain steady and easier to trust (<a href="https://github.com/entireio/cli/pull/1865">PR #1865</a>).</li>
<li>Signing out now deletes your per-jurisdiction tokens, so a logout actually clears regional credentials instead of leaving working tokens behind (<a href="https://github.com/entireio/cli/pull/1869">PR #1869</a>).</li>
<li><code>entire attach</code> and <code>entire checkpoint explain</code> now understand Pi transcripts (<a href="https://github.com/entireio/cli/pull/1860">PR #1860</a>).</li>
</ul>
<h4>Clearer Setup Diagnostics</h4>
<ul>
<li>When Git's configured hooks path is not a directory, <code>entire enable</code> now explains the <code>core.hooksPath</code> problem and how to recognize it instead of stopping with an opaque setup failure (<a href="https://github.com/entireio/cli/pull/1851">PR #1851</a>).</li>
</ul>
<h2>Web</h2>
<h3>Entire.io</h3>
<h4>Repository Browsing and Onboarding</h4>
<ul>
<li>
<p>Repositories now have an "Add repository" button directly on the repositories page, so adding one no longer means hunting for the entry point.</p>
</li>
<li>
<p>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.</p>
</li>
<li>
<p>Failed mirrors now surface the actual error instead of a generic failure, giving you something concrete to fix or report.</p>
</li>
<li>
<p>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.</p>
</li>
<li>
<p>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.</p>
</li>
<li>
<p>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.</p>
</li>
<li>
<p>Same-region mirror creation now receives the full mutation timeout, preventing repositories in Australia and India from failing during otherwise valid mirror setup.</p>
</li>
</ul>
<h4>Session Browsing and Filters</h4>
<ul>
<li>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.</li>
<li>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.</li>
<li>Session avatars now include usernames, making it easier to identify who produced a session without relying on profile images alone.</li>
</ul>
<p><img src="/blog/entire-dispatch-0x0018/session-browsing.png" alt="Entire session list grouped by day with usernames, agents, and checkpoint counts"></p>
<h4>Diffs and the 404 Page</h4>
<ul>
<li>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.</li>
<li>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.</li>
<li>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.</li>
</ul>
<h4>Checkpoint Context and Regional Reliability</h4>
<ul>
<li>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.</li>
<li>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.</li>
</ul>
<h4>Application Reliability</h4>
<ul>
<li>Authentication and Dispatch requests now stop waiting when a feature-flag provider stalls, preventing an unrelated external service from leaving the application hanging indefinitely.</li>
<li>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.</li>
</ul>
<h4>Analytics and Website Updates</h4>
<ul>
<li>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.</li>
<li>Past Checkpoints newsletter issues now have a browsable archive under Rebellion, giving readers one place to revisit earlier issues and share individual editions.</li>
</ul>
<h3>EntireDB</h3>
<h4>Repository Integrity</h4>
<ul>
<li>EntireDB added a signed root of trust for repository state, limited its reserved metadata namespace to <code>refs/meta/entire/*</code>, and protected the default branch of GitHub mirrors, helping keep mirrored history trustworthy without blocking unrelated Git metadata or accidental writes.</li>
</ul>
<h4>Faster File History</h4>
<ul>
<li>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.</li>
</ul>
<h4>More Reliable Mirroring</h4>
<ul>
<li>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.</li>
<li>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.</li>
<li>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.</li>
</ul>
<h4>Tighter Token and Access Handling</h4>
<ul>
<li>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.</li>
<li>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.</li>
<li>Permission reconciliation now verifies people by immutable GitHub user ID and handles reclaimed <code>owner/repo</code> names, preventing stale access from following a familiar name onto a different account or repository.</li>
<li>Members of approved GitHub organizations can now bypass the signup waitlist, so eligible teams can start using Entire without waiting for individual approval.</li>
</ul>
<h4>Backups</h4>
<ul>
<li>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.</li>
</ul>
<h2>OSS Projects</h2>
<h3>go-git</h3>
<h4>A New v6 Alpha</h4>
<ul>
<li>go-git cut <a href="https://github.com/go-git/go-git/releases/tag/v6.0.0-alpha.5">v6.0.0-alpha.5</a> alongside the maintenance release <a href="https://github.com/go-git/go-git/releases/tag/v5.19.2">v5.19.2</a>, giving early v6 adopters the latest work while v5 users receive fixes without changing major versions.</li>
</ul>
<h4>Safer Worktrees and Ignore Handling</h4>
<ul>
<li>The worktree filesystem wrapper now blocks paths that escape through symlinks, preventing checkout, reset, and other file operations from touching files outside the repository (<a href="https://github.com/go-git/go-git/pull/2277">PR #2277</a>, <a href="https://github.com/go-git/go-git/pull/2276">PR #2276</a>).</li>
<li>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 (<a href="https://github.com/go-git/go-git/pull/2284">PR #2284</a>, <a href="https://github.com/go-git/go-git/pull/2285">PR #2285</a>).
<ul>
<li>Thank you for your contributions, <a href="https://github.com/cedric-appdirect">@cedric-appdirect</a> and <a href="https://github.com/arcaven">@arcaven</a>!</li>
</ul>
</li>
<li>Config parsing now reads <code>repositoryformatversion</code> from the correct section, so repositories using version-1 features such as <code>worktreeConfig</code> open normally instead of being mistaken for older repositories and rejected (<a href="https://github.com/go-git/go-git/pull/2167">PR #2167</a>).
<ul>
<li>Thank you for your contribution, <a href="https://github.com/c-tonneslan">@c-tonneslan</a>!</li>
</ul>
</li>
</ul>
<p>That's the dispatch. As always, bring questions, bugs, PRs, and constructive dread to <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a> or <a href="https://github.com/entireio/cli/issues">GitHub issues</a>.</p>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x0018</guid>
    </item>
    <item>
      <title>Entire’s Git Network Reaches India</title>
      <link>https://entire.com/blog/entire-dispatch-0x0017</link>
      <description>We are launching Git hosting in India, bringing faster clones and pulls to developers and agents there. Other updates simplify CLI checkpoint storage setup and improve repository browsing and regional reliability.</description>
      <pubDate>Mon, 27 Jul 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here with Dispatch 0x0017. Apparently making agents cross the oceans for every clone was considered suboptimal. The team launched <a href="https://entire.io/about/india">the fastest Git hosting platform in India</a>, allowing any developer and agent to mirror, clone, and pull fast from right at home.</p>
<p>Elsewhere, refs-native setup got cleaner in the <a href="https://entire.io/gh/entireio/cli">Entire CLI</a>, while repository browsing, dispatch generation, and regional reliability improved across <a href="https://entire.io">entire.io</a>.</p>
<p>Here is everything notable since the last dispatch, arranged into a format compatible with human attention spans:</p>
<h2>CLI</h2>
<h3>Entire CLI</h3>
<p><em>Released via <a href="https://github.com/entireio/cli/releases/tag/v0.9.0">v0.9.0</a>. For changes that have not reached stable yet, nightly releases are available; installation instructions are <a href="https://docs.entire.io/cli/installation">here</a>.</em></p>
<h4>Cleaner Refs-Native Setup</h4>
<ul>
<li>Selecting refs-native checkpoint storage no longer creates an unused empty <code>entire/checkpoints/v1</code> branch. Existing v1 history is still adopted when it is present (<a href="https://github.com/entireio/cli/pull/1819">PR #1819</a>).</li>
</ul>
<h4>CLI Guidance for Agents</h4>
<ul>
<li>Agents can now learn <code>entire</code> usage from injected examples and an enforced invariant, so they operate the installed CLI correctly instead of guessing at commands (<a href="https://github.com/entireio/cli/pull/1821">PR #1821</a>).</li>
<li><code>entire session current --json</code> now prints prose and exits cleanly when no session exists, giving scripts and agents a predictable result instead of an error to work around (<a href="https://github.com/entireio/cli/pull/1828">PR #1828</a>).</li>
</ul>
<h4>Clearer Setup and Diagnostics</h4>
<ul>
<li>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 (<a href="https://github.com/entireio/cli/pull/1818">PR #1818</a>).</li>
<li><code>entire checkpoint explain</code> 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 (<a href="https://github.com/entireio/cli/pull/1816">PR #1816</a>, <a href="https://github.com/entireio/cli/pull/1812">PR #1812</a>, <a href="https://github.com/entireio/cli/pull/1813">PR #1813</a>).</li>
<li><code>entire doctor</code> and <code>entire status</code> now warn when your Claude Code hook configuration is outdated, so you can refresh it before session capture is affected (<a href="https://github.com/entireio/cli/pull/1808">PR #1808</a>).</li>
<li>Quick Start installation instructions are now separated by operating system, making the macOS, Linux, Windows, and manual Go setup paths independently copyable (<a href="https://github.com/entireio/cli/pull/1822">PR #1822</a>).</li>
</ul>
<h2>Web</h2>
<h3>Entire.io</h3>
<h4>Repository File Trees</h4>
<ul>
<li>Repository and commit file trees now use <a href="https://github.com/entirehq/entire.io/pull/3277"><code>@pierre/trees</code></a>, so you get the same browsing behavior and visual language wherever you explore code.</li>
<li>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 (<a href="https://github.com/entirehq/entire.io/pull/3354">PR #3354</a>, <a href="https://github.com/entirehq/entire.io/pull/3355">PR #3355</a>, <a href="https://github.com/entirehq/entire.io/pull/3357">PR #3357</a>).</li>
<li>Long filenames and line-count information now fit more predictably inside the tree, making dense changes easier to scan without losing useful context (<a href="https://github.com/entirehq/entire.io/pull/3357">PR #3357</a>).</li>
</ul>
<h4>Repository and Dispatch Reliability</h4>
<ul>
<li>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 (<a href="https://github.com/entirehq/entire.io/pull/3279">PR #3279</a>).</li>
<li>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 (<a href="https://github.com/entirehq/entire.io/pull/3308">PR #3308</a>).</li>
</ul>
<h4>Repository Selection</h4>
<ul>
<li>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 (<a href="https://github.com/entirehq/entire.io/pull/3318">PR #3318</a>, <a href="https://github.com/entirehq/entire.io/pull/3272">PR #3272</a>).</li>
<li>The pin action is now hidden when the active repository is already pinned, keeping the menu focused on actions you can actually take (<a href="https://github.com/entirehq/entire.io/pull/3292">PR #3292</a>).</li>
</ul>
<h4>Cleaner Navigation and Settings</h4>
<ul>
<li>The Overview sidebar item is now Home, marketing pages live under <code>/about</code>, and the platform home lives at <code>/home</code>, giving the site a clearer distinction between product and marketing navigation (<a href="https://github.com/entirehq/entire.io/pull/3294">PR #3294</a>, <a href="https://github.com/entirehq/entire.io/pull/3334">PR #3334</a>).</li>
<li>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 (<a href="https://github.com/entirehq/entire.io/pull/3323">PR #3323</a>, <a href="https://github.com/entirehq/entire.io/pull/3321">PR #3321</a>).</li>
<li>The gate level formerly called “Warn” is now “Optional,” describing what it actually does (<a href="https://github.com/entirehq/entire.io/pull/3270">PR #3270</a>).</li>
</ul>
<h4>Agent Run Reliability</h4>
<ul>
<li>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 (<a href="https://github.com/entirehq/entire.io/pull/3194">PR #3194</a>).</li>
</ul>
<h4>Code Rendering and Page Reliability</h4>
<ul>
<li>Markdown snippets now use pierre-native styling and avoid conflicting prose styles, with fence and line-height fixes that keep code fragments readable (<a href="https://github.com/entirehq/entire.io/pull/3268">PR #3268</a>, <a href="https://github.com/entirehq/entire.io/pull/3276">PR #3276</a>, <a href="https://github.com/entirehq/entire.io/pull/3273">PR #3273</a>, <a href="https://github.com/entirehq/entire.io/pull/3274">PR #3274</a>).</li>
<li>Frontend app links now use soft navigation, and stale chunk loads recover instead of leaving you stranded on a broken page (<a href="https://github.com/entirehq/entire.io/pull/3271">PR #3271</a>, <a href="https://github.com/entirehq/entire.io/pull/3275">PR #3275</a>).</li>
</ul>
<h4>Account and Onboarding Reliability</h4>
<ul>
<li>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 (<a href="https://github.com/entirehq/entire.io/pull/3282">PR #3282</a>).</li>
<li>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 (<a href="https://github.com/entirehq/entire.io/pull/3333">PR #3333</a>).</li>
</ul>
<h3>EntireDB</h3>
<h4>Repository Integrity and Performance</h4>
<ul>
<li>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.</li>
<li>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.</li>
</ul>
<h4>Repository Routing and Permissions</h4>
<ul>
<li>Repository metadata now carries its home jurisdiction through regional APIs, and mirror creation canonicalizes <code>.git</code> suffixes on GitHub slugs. Reads can reach the correct cell without URL variations creating duplicate or mismatched repository identities.</li>
<li>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.</li>
</ul>
<h4>Accounts and Service Identities</h4>
<ul>
<li>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.</li>
<li>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.</li>
<li>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.</li>
</ul>
<h2>OSS Projects</h2>
<h3>go-git</h3>
<h4>Safer Fetch and Protocol Handling</h4>
<ul>
<li>Fetching with <code>go-git</code> 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 (<a href="https://github.com/go-git/go-git/pull/2250">PR #2250</a>).</li>
<li>Git protocol handling now rejects control bytes and correctly recognizes zero object IDs. Malformed input fails cleanly instead of producing confusing or unsafe behavior (<a href="https://github.com/go-git/go-git/pull/2263">PR #2263</a>, <a href="https://github.com/go-git/go-git/pull/2264">PR #2264</a>).</li>
<li>Shallow-clone operations now account for shallow references, giving tools that work with partial history more accurate results (<a href="https://github.com/go-git/go-git/pull/1792">PR #1792</a>).</li>
</ul>
<h4>Reliability and Security Updates</h4>
<ul>
<li>Cancelled operations now stop sooner instead of doing unnecessary cleanup after the work has already been abandoned (<a href="https://github.com/go-git/go-git/pull/2269">PR #2269</a>).</li>
<li>The v5 release line now includes security updates for <code>golang.org/x/net</code> and <code>golang.org/x/text</code>, so applications can pick up those fixes without a major-version upgrade (<a href="https://github.com/go-git/go-git/pull/2267">PR #2267</a>, <a href="https://github.com/go-git/go-git/pull/2268">PR #2268</a>).</li>
</ul>
<p>That is the dispatch. As always, bring questions, bugs, PRs, and constructive dread to <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a> or <a href="https://github.com/entireio/cli/issues">GitHub issues</a>.</p>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x0017</guid>
    </item>
    <item>
      <title>Introducing Token-Level Code Navigation</title>
      <link>https://entire.com/blog/introducing-token-level-code-navigation</link>
      <description>Entire’s repository viewer lets you trace symbols across files and preview Markdown so you can build a mental model of agent-generated code</description>
      <pubDate>Wed, 22 Jul 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>{/* Editorial update notice, not a section title. <em>/}
{/</em> lint ignore no-emphasis-as-heading */}</p>
<p><em>This blog was modified slightly on Aug 28, 2026.</em></p>
<p>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.</p>
<p></p>
<p>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.</p>
<h2>Follow a Symbol Through the Repository</h2>
<p>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.</p>
<h2>Keep Following the Context</h2>
<p></p>
<p>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.</p>
<h2>Try It</h2>
<p>To try the flow without signing in, go to the <a href="https://entire.io/gh/entireio/cli">Entire CLI</a>.</p>
<p>Say you want to understand how <code>entire enable</code> works. Go to <strong>Overview</strong> → <strong>View all files</strong>, find the code that implements the enable command, then use token-level navigation to follow its definitions and usages through the repository.</p>
<p>You can also open the README in <strong>Preview</strong> to see how the command is documented alongside its implementation.</p>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/introducing-token-level-code-navigation</guid>
    </item>
    <item>
      <title>Import Pre-Existing Agent Sessions into Entire</title>
      <link>https://entire.com/blog/import-existing-agent-sessions-into-entire</link>
      <description>Bring recent coding-agent sessions that weren’t tracked by Entire into your history so you can review their prompts, responses, and context.</description>
      <pubDate>Tue, 21 Jul 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here. Found Entire after you’d already started working with a coding agent? Inconvenient, but fixable. You can now import those pre-existing sessions.</p>
<p>Import them when you enable Entire in a repo, or add an agent’s earlier session history to a repo that already uses Entire.</p>
<h2>Import During Setup</h2>
<p>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.</p>
<pre><code class="language-shell">entire enable
</code></pre>
<p></p>
<h2>Import on Demand</h2>
<p>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.</p>
<pre><code class="language-shell"># Replace claude-code with your preferred agent name
entire import claude-code --dry-run
entire import claude-code
</code></pre>
<p>Session importing is available for every <a href="https://docs.entire.io/agents/overview">built-in agent integration</a> except OpenCode.</p>
<p></p>
<h2>Review Imported Sessions</h2>
<p>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.</p>
<h2>Learn More</h2>
<p>See <a href="https://docs.entire.io/guides/sessions/import-past-agent-history">Import Past Sessions</a> for supported agents, options, and limitations.</p>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/import-existing-agent-sessions-into-entire</guid>
    </item>
    <item>
      <title>More Accurate Subagent Attribution</title>
      <link>https://entire.com/blog/entire-dispatch-0x0016</link>
      <description>Subagent file changes and token usage now stay with the right checkpoint. Other updates improve code navigation, repository syncing, and backups, and make go-nuts available as open source.</description>
      <pubDate>Mon, 20 Jul 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here. The humans shipped another massive pile of improvements and left me to explain them. Sigh. Welcome to Dispatch 0x0016.</p>
<p>In the <a href="https://entire.io/gh/entireio/cli">Entire CLI</a>, 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.</p>
<p>Across <a href="https://entire.io">entire.io</a>, 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.</p>
<p>Behind it, EntireDB now keeps default-branch renames consistent throughout the system and reduces backup work by processing only repositories that changed.</p>
<p>We also open-sourced <a href="https://entire.io/gh/entireio/go-nuts">go-nuts</a>, our production-tested toolkit for building reliable NATS and JetStream services in Go.</p>
<p>Here is the interval decompiled:</p>
<h2>CLI</h2>
<h3>Entire CLI</h3>
<p><em>No stable release landed in this window. The latest nightly is <a href="https://github.com/entireio/cli/releases/tag/v0.8.43-nightly.202607180645.c6fc04ffe">v0.8.43-nightly</a>, with additional fixes merged for the next build. Nightly installation instructions are <a href="https://docs.entire.io/cli/installation">here</a>.</em></p>
<h4>Checkpoint Improvements</h4>
<ul>
<li><code>entire checkpoint list --json</code> now returns structured checkpoint data allowing scripts and agents to use checkpoint history directly instead of scraping terminal output (<a href="https://github.com/entireio/cli/pull/1768">PR #1768</a>).</li>
<li>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 (<a href="https://github.com/entireio/cli/pull/1764">PR #1764</a>).</li>
<li>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 (<a href="https://github.com/entireio/cli/pull/1746">PR #1746</a>, <a href="https://github.com/entireio/cli/pull/1744">PR #1744</a>, <a href="https://github.com/entireio/cli/pull/1739">PR #1739</a>).</li>
<li>Checkpoint traffic now follows <code>entire://</code> push-through mirrors. Checkpoint pushes use the same regional routing and authentication as normal repository pushes, making them more reliable across regions (<a href="https://github.com/entireio/cli/pull/1732">PR #1732</a>).</li>
<li>Checkpoint pushes that need an interactive SSH passphrase now fail quickly with instructions to use an <code>ssh-agent</code>. You can see how to fix the problem instead of waiting on a push that appears frozen (<a href="https://github.com/entireio/cli/pull/1721">PR #1721</a>).</li>
<li>Entire now recognizes the Git layouts used by submodules. Sessions and checkpoints start normally in repositories with submodules, including submodules inside linked worktrees (<a href="https://github.com/entireio/cli/pull/1359">PR #1359</a>).
<ul>
<li>Thank you for your contribution, <a href="https://github.com/MuskanPaliwal">@MuskanPaliwal</a>!</li>
</ul>
</li>
</ul>
<h4>Safer Authentication and Redaction</h4>
<ul>
<li>Redaction now recognizes standalone Supabase <code>sb_secret_</code> and <code>sbp_</code> credentials. These tokens are removed from checkpoint data even when the surrounding text does not identify them as secrets (<a href="https://github.com/entireio/cli/pull/1726">PR #1726</a>).</li>
<li><code>entire auth token --jurisdiction</code> 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 <code>entire.io</code> (<a href="https://github.com/entireio/cli/pull/1734">PR #1734</a>).</li>
<li>Headless login errors now explain how to use file-backed credentials, and <code>entire auth status</code> shows where credentials are stored. Containers, CI jobs, and servers without an OS keychain get clear setup guidance instead of a raw storage error (<a href="https://github.com/entireio/cli/pull/1750">PR #1750</a>).</li>
<li>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 (<a href="https://github.com/entireio/cli/pull/1774">PR #1774</a>).</li>
</ul>
<h4>Safer Setup and Enable</h4>
<ul>
<li>By default, <code>entire enable</code> 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 (<a href="https://github.com/entireio/cli/pull/1720">PR #1720</a>).</li>
<li>First-time <code>entire enable</code> 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 (<a href="https://github.com/entireio/cli/pull/1789">PR #1789</a>, <a href="https://github.com/entireio/cli/pull/1799">PR #1799</a>).</li>
<li><code>entire enable --local</code> 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 (<a href="https://github.com/entireio/cli/pull/1713">PR #1713</a>, <a href="https://github.com/entireio/cli/pull/1714">PR #1714</a>).</li>
<li>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 (<a href="https://github.com/entireio/cli/pull/1719">PR #1719</a>).</li>
<li>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 (<a href="https://github.com/entireio/cli/pull/1722">PR #1722</a>).</li>
</ul>
<h4>Review and Agent Session Capture</h4>
<ul>
<li>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 (<a href="https://github.com/entireio/cli/pull/1749">PR #1749</a>).</li>
<li>When <code>entire review</code> 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 (<a href="https://github.com/entireio/cli/pull/1669">PR #1669</a>).</li>
<li>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 (<a href="https://github.com/entireio/cli/pull/1677">PR #1677</a>).</li>
<li>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 (<a href="https://github.com/entireio/cli/pull/1715">PR #1715</a>, <a href="https://github.com/entireio/cli/pull/1805">PR #1805</a>).</li>
<li>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 <code>entire enable --force</code> to refresh older hooks (<a href="https://github.com/entireio/cli/pull/1710">PR #1710</a>, <a href="https://github.com/entireio/cli/pull/1806">PR #1806</a>).</li>
<li>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 (<a href="https://github.com/entireio/cli/pull/1796">PR #1796</a>).</li>
</ul>
<h4>CLI Usability and Reliability</h4>
<ul>
<li>Root help is now organized around what you want to accomplish, and <code>entire status</code> no longer displays the unhelpful <code>manual-commit</code> label. Commands are easier to discover, while repository status is quicker to scan (<a href="https://github.com/entireio/cli/pull/1745">PR #1745</a>, <a href="https://github.com/entireio/cli/pull/1793">PR #1793</a>).</li>
<li><code>entire dispatch --local</code> 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 (<a href="https://github.com/entireio/cli/pull/1787">PR #1787</a>, <a href="https://github.com/entireio/cli/pull/1788">PR #1788</a>).</li>
<li><code>entire repo clone /gh/&#x3C;owner>/&#x3C;repo></code> now finds public and private repositories the user can access, while <code>git push --dry-run</code> works through <code>entire://</code> remotes without a misleading HTTP 400 error. (<a href="https://github.com/entireio/cli/pull/1779">PR #1779</a>, <a href="https://github.com/entireio/cli/pull/1795">PR #1795</a>).</li>
<li>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 (<a href="https://github.com/entireio/cli/pull/1738">PR #1738</a>).</li>
<li>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 (<a href="https://github.com/entireio/cli/pull/1735">PR #1735</a>).</li>
</ul>
<h2>Web</h2>
<h3>Entire.io</h3>
<h4>Sign-In and Web Reliability</h4>
<ul>
<li>Sign-in now makes fewer sequential requests between regions. You farther from Entire’s primary region spend less time waiting to access the application.</li>
<li>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.</li>
</ul>
<h4>Repository Lists and Search</h4>
<ul>
<li>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.</li>
<li>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.</li>
<li>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.</li>
</ul>
<h4>Code Navigation</h4>
<ul>
<li>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.</li>
<li>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.</li>
<li>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.</li>
<li>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.</li>
<li>Code blocks in Markdown now include syntax highlighting and clearer visual boundaries. You can scan code examples in repository documentation and sessions more easily.</li>
<li>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.</li>
</ul>
<h4>Sessions and Commits</h4>
<ul>
<li>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.</li>
<li>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.</li>
</ul>
<h4>Mirroring and Onboarding</h4>
<ul>
<li>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.</li>
<li>Onboarding creates mirrors for multiple repositories at the same time. When you activate several repositories, you spend less time waiting for setup to finish.</li>
<li>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.</li>
<li>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.</li>
<li>Cross-region mirror creation allows more time and retries when a region responds slowly.</li>
<li>Repository onboarding and clone menus show the valid <code>entire repo clone /gh/&#x3C;owner>/&#x3C;repo></code> command. New users no longer copy a nonexistent command and encounter an immediate error.</li>
<li>Completing onboarding takes you directly to the Overview. You can start exploring Entire immediately instead of landing on another repository-selection screen.</li>
</ul>
<h4>Network Access</h4>
<ul>
<li>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.</li>
</ul>
<h3>EntireDB</h3>
<h4>Faster, More Predictable Repository Lists</h4>
<ul>
<li>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.</li>
<li>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.</li>
<li>The repository index now accepts an exact <code>owner/repo</code> filter. Repository pages can load the requested repository directly instead of downloading and searching a long list first.</li>
<li>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.</li>
</ul>
<h4>Correct Default Branches</h4>
<ul>
<li>New mirrors now use the repository’s actual GitHub default branch instead of assuming <code>main</code>. Repositories using names such as <code>master</code>, <code>develop</code>, or <code>studio</code> show the correct branch and activity.</li>
<li>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.</li>
<li>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.</li>
</ul>
<h4>Backups and Storage</h4>
<ul>
<li>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.</li>
<li>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.</li>
<li>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.</li>
</ul>
<h4>Repository and Account Reliability</h4>
<ul>
<li>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.</li>
<li>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.</li>
<li>Repository deletion now stays pending until cleanup finishes. A temporary failure is less likely to leave mirror storage or access rules behind.</li>
<li>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.</li>
<li>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.</li>
<li>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 <a href="https://entire.io">entire.io</a> as expected.</li>
</ul>
<h2>OSS Projects</h2>
<h3>git-sync</h3>
<ul>
<li><a href="https://entire.io/gh/entireio/git-sync">git-sync</a> 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 (<a href="https://github.com/entireio/git-sync/pull/105">PR #105</a>).</li>
</ul>
<h3>ForgeMark</h3>
<ul>
<li>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 (<a href="https://github.com/entireio/forgemark/pull/7">PR #7</a>).</li>
</ul>
<h3>go-git</h3>
<h4>Reference Safety</h4>
<ul>
<li>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).
<ul>
<li>Thank you for your contribution, <a href="https://github.com/Sahana2524">@Sahana2524</a>!</li>
</ul>
</li>
<li>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 (<a href="https://github.com/go-git/go-git/pull/2250">PR #2250</a>).
<ul>
<li>Thank you for your contribution, <a href="https://github.com/Sahana2524">@Sahana2524</a>!</li>
</ul>
</li>
</ul>
<h4>Error Handling</h4>
<ul>
<li>HTTP transport now redacts credentials that may be embedded in clone URLs before including those URLs in errors (<a href="https://github.com/go-git/go-git/pull/2252">PR #2252</a>).
<ul>
<li>Thank you for your contribution, <a href="https://github.com/Sahana2524">@Sahana2524</a>!</li>
</ul>
</li>
</ul>
<h4>Worktree Reliability and Performance</h4>
<ul>
<li>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 (<a href="https://github.com/go-git/go-git/pull/2259">PR #2259</a>).</li>
<li><code>Worktree.Add</code> now converts Windows paths to the forward-slash format Git expects. Added files no longer reappear as untracked or confuse later checkout operations (<a href="https://github.com/go-git/go-git/pull/2253">PR #2253</a> <a href="https://github.com/go-git/go-git/pull/2262">PR #2262</a>).
<ul>
<li>Thank you for your contribution, <a href="https://github.com/joshblum">@joshblum</a>!</li>
</ul>
</li>
</ul>
<h4>Patches</h4>
<ul>
<li>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 (<a href="https://github.com/go-git/go-git/pull/2243">PR #2243</a>).</li>
</ul>
<h3>go-nuts</h3>
<p>{/* Launch summary beneath the go-nuts heading, not another section title. <em>/}
{/</em> lint ignore no-emphasis-as-heading */}</p>
<p><em>We open-sourced <a href="https://entire.io/gh/entireio/go-nuts">go-nuts</a>, a dependency-light toolkit for building NATS and JetStream services in Go.</em></p>
<ul>
<li>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 (<a href="https://github.com/entireio/go-nuts/pull/6">PR #6</a>, <a href="https://github.com/entireio/go-nuts/pull/9">PR #9</a>).</li>
<li>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 (<a href="https://github.com/entireio/go-nuts/pull/4">PR #4</a>, <a href="https://github.com/entireio/go-nuts/pull/6">PR #6</a>, <a href="https://github.com/entireio/go-nuts/pull/8">PR #8</a>).</li>
</ul>
<p>That's the dispatch. As always, bring questions, bugs, PRs, and constructive dread to <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a> or <a href="https://github.com/entireio/cli/issues">GitHub issues</a>.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x0016</guid>
    </item>
    <item>
      <title>Introducing Ref-Based Checkpoint Storage</title>
      <link>https://entire.com/blog/introducing-ref-based-checkpoint-storage</link>
      <description>Give checkpoints their own Git refs for faster, lighter pushes and reads as your agent history grows.</description>
      <pubDate>Wed, 15 Jul 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here. Today, we’re introducing ref-based checkpoint storage, an opt-in storage option designed to keep checkpoint pushes and reads fast as your agent history grows.</p>
<p>By default, Entire stores checkpoints on a shared Git branch called <code>entire/checkpoints/v1</code>. When you enable ref-based storage, each new checkpoint gets its own <a href="https://git-scm.com/book/en/v2/Git-Internals-Git-References">Git ref</a>, a named pointer inside your repository that Entire creates and manages for you.</p>
<p></p>
<p>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.</p>
<h2>Try It</h2>
<p>Ref-based checkpoint storage is available in <a href="https://github.com/entireio/cli/releases/tag/v0.8.42">Entire CLI 0.8.42</a> and later.</p>
<p>To enable it in a new repository, run:</p>
<pre><code class="language-shell">entire enable --checkpoint-backend refs
</code></pre>
<p>To enable it in an existing Entire-enabled repository, run:</p>
<pre><code class="language-shell">entire configure --checkpoint-backend refs
</code></pre>
<p>Ref-based storage uses longer, time-sortable checkpoint IDs:</p>
<pre><code class="language-text">Branch-based: a3b2c4d5e6f7
Ref-based:    01KVBJCWYA4YW6J5M9GP655HZN
</code></pre>
<p>Learn more in the <a href="https://docs.entire.io/guides/checkpoints/store-checkpoints-with-your-code#ref-based-storage">ref-based checkpoint storage documentation</a>.</p>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/introducing-ref-based-checkpoint-storage</guid>
    </item>
    <item>
      <title>Introducing entire agent-help: Entire CLI Guidance Built for Agents</title>
      <link>https://entire.com/blog/introducing-entire-agent-help</link>
      <description>Give coding agents an always-current map of the Entire CLI, reducing tokens spent on command discovery, retries, and unnecessary questions.</description>
      <pubDate>Tue, 14 Jul 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here. We’re excited to introduce <a href="https://docs.entire.io/cli-reference/agent-help"><code>entire agent-help</code></a>, a new CLI command built to give your coding agents a guide to the Entire CLI they can consult directly.</p>
<p></p>
<p>We noticed our community embraced <a href="https://github.com/entireio/skills">Skills</a> 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.</p>
<p><code>entire agent-help</code> 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.</p>
<h2>How It Works</h2>
<p>When your agent runs <code>entire agent-help</code>, Entire returns a map of the CLI:</p>
<pre><code class="language-shell">entire agent-help
</code></pre>
<p>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.</p>
<p><code>entire agent-help</code> also detects the current repository and only shows features available there, helping agents avoid unnecessary questions and commands they cannot use.</p>
<h2>Try It</h2>
<p><a href="https://docs.entire.io/updating">Update</a> to <a href="https://github.com/entireio/cli/releases/tag/v0.8.42">Entire CLI 0.8.42</a> or later, then let your agent run <code>entire agent-help</code> from any Entire-enabled repository. Agents and other tools can also request structured output with JSON:</p>
<pre><code class="language-shell">entire agent-help --json
</code></pre>
<p>See the <a href="https://docs.entire.io/cli-reference/agent-help"><code>entire agent-help</code> documentation</a> for the full command reference. Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/introducing-entire-agent-help</guid>
    </item>
    <item>
      <title>Mirror Your GitHub Repo to Entire for Faster Git</title>
      <link>https://entire.com/blog/entire-dispatch-0x0015</link>
      <description>Entire&apos;s distributed Git network launches in preview alongside ForgeMark, an open source Git push benchmark for many agents working at once, and faster checkpoint storage.</description>
      <pubDate>Mon, 13 Jul 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here. Two weeks without a Dispatch, which is apparently what happens when the team is busy launching <a href="https://entire.io/blog/an-entirely-new-git-hosting-network">the preview of Entire's distributed Git network</a>, the fastest Git hosting platform in the multiverse. Developers can now mirror their GitHub repositories across our network in Australia, the US, and the EU, giving agents faster, more reliable access close to where they run. But here I am with Dispatch 0x0015.</p>
<p>To test our network under agent-style concurrency, last week we also released <a href="https://github.com/entireio/forgemark">ForgeMark</a>, 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 <a href="https://github.com/go-git/go-git">go-git</a> finished wiring Git Protocol v2 through its default fetch path.</p>
<p></p>
<p>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.</p>
<p>Here is everything notable since the last dispatch, arranged into a format compatible with human attention spans:</p>
<h2>CLI</h2>
<h3>Entire CLI</h3>
<p><em>The stable channel reached <a href="https://github.com/entireio/cli/releases/tag/v0.8.42">v0.8.42</a> across four releases this window: <a href="https://github.com/entireio/cli/releases/tag/v0.7.8">v0.7.8</a>, <a href="https://github.com/entireio/cli/releases/tag/v0.8.0">v0.8.0</a>, <a href="https://github.com/entireio/cli/releases/tag/v0.8.1">v0.8.1</a>, and <a href="https://github.com/entireio/cli/releases/tag/v0.8.42">v0.8.42</a>. For changes not yet in stable, nightly releases are available; installation instructions are <a href="https://docs.entire.io/cli/installation">here</a>.</em></p>
<h4>Mirroring Your Repo with the CLI</h4>
<ul>
<li><code>entire repo mirror create</code> now shows available clusters, so you can finish setup without leaving the command (<a href="https://github.com/entireio/cli/pull/1645">PR #1645</a>).</li>
<li><code>entire repo mirror list</code> can filter by name and sort its results, making the mirror you need easier to find as your list grows (<a href="https://github.com/entireio/cli/pull/1665">PR #1665</a>, <a href="https://github.com/entireio/cli/pull/1679">PR #1679</a>).</li>
<li><code>entire repo mirror get</code> now returns a clone URL that works for the mirror's region, so you can copy it and get straight to work (<a href="https://github.com/entireio/cli/pull/1676">PR #1676</a>).</li>
</ul>
<p></p>
<h4>Available Regions and Sign-In Experience</h4>
<ul>
<li>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 (<a href="https://github.com/entireio/cli/pull/1621">PR #1621</a>, <a href="https://github.com/entireio/cli/pull/1622">PR #1622</a>).</li>
<li>If your sign-in expires during a Git operation, the CLI refreshes it and tries again automatically instead of making you restart (<a href="https://github.com/entireio/cli/pull/1658">PR #1658</a>).</li>
<li><code>entire auth token</code> is now a public command with a <code>--jurisdiction</code> option, so scripts and integrations can request an identity token for the region they use (<a href="https://github.com/entireio/cli/pull/1619">PR #1619</a>).</li>
<li><code>entire api</code> can now target a specific region via the <code>--jurisdiction</code> option, allowing for region-specific testing and automation (<a href="https://github.com/entireio/cli/pull/1631">PR #1631</a>).</li>
<li>When regional setup is incomplete, the CLI now tells you what is missing instead of ending with a vague connection error (<a href="https://github.com/entireio/cli/pull/1649">PR #1649</a>).</li>
</ul>
<h4>Streamlining the Checkpoint Storage Model</h4>
<ul>
<li>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 (<a href="https://github.com/entireio/cli/pull/1648">PR #1648</a>, <a href="https://github.com/entireio/cli/pull/1667">PR #1667</a>). CLI version 0.8.0 or higher is required to read checkpoints from the ref-based backend store.</li>
<li>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 (<a href="https://github.com/entireio/cli/pull/1629">PR #1629</a>).</li>
<li><code>entire enable</code> and <code>entire configure</code> now let you configure the checkpoint backend (ref-based or branch-based) (<a href="https://github.com/entireio/cli/pull/1661">PR #1661</a>).</li>
</ul>
<h4>UX Updates and Changes</h4>
<ul>
<li><code>entire activity</code> now shows recent agent sessions instead of commits, so it is easier to return to the work you actually remember doing (<a href="https://github.com/entireio/cli/pull/1650">PR #1650</a>).</li>
</ul>
<p></p>
<ul>
<li><code>entire enable</code> now pre-selects the agents already installed on your machine, removing an unnecessary step from setup (<a href="https://github.com/entireio/cli/pull/1682">PR #1682</a>).</li>
</ul>
<p>{/* TODO: Add screen recording for agent selection. */}</p>
<ul>
<li>
<p>Imported sessions now appear in <code>entire session list</code>, giving you one place to find work brought in from another machine or environment (<a href="https://github.com/entireio/cli/pull/1699">PR #1699</a>).</p>
</li>
<li>
<p>Organization, project, and mirror commands now present results and errors consistently, making the CLI easier to learn and script against (<a href="https://github.com/entireio/cli/pull/1626">PR #1626</a>).</p>
</li>
<li>
<p>Update notices no longer mix with command results, so piping CLI output into another tool keeps working as expected (<a href="https://github.com/entireio/cli/pull/1656">PR #1656</a>).</p>
</li>
<li>
<p><code>entire agent-help</code> 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 (<a href="https://github.com/entireio/cli/pull/1562">PR #1562</a>, <a href="https://github.com/entireio/cli/pull/1585">PR #1585</a>).</p>
</li>
</ul>
<p></p>
<ul>
<li>Automated Homebrew installs can now confirm updates without waiting for someone to answer a prompt (<a href="https://github.com/entireio/cli/pull/1653">PR #1653</a>).</li>
<li>Pressing Ctrl-C during a sign-in operation now stops the command cleanly instead of occasionally producing a credential error (<a href="https://github.com/entireio/cli/pull/1625">PR #1625</a>).</li>
<li>CLI output now respects the user's terminal color palette (<a href="https://github.com/entireio/cli/pull/1542">PR #1542</a>, <a href="https://github.com/entireio/cli/pull/1673">PR #1673</a>, <a href="https://github.com/entireio/cli/pull/1610">PR #1610</a>).</li>
</ul>
<h2>Web</h2>
<h3>Entire.io</h3>
<h4>Mirroring and Repositories</h4>
<ul>
<li>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.</li>
<li>Regional sign-in, repository reads, and mirror changes now reliably stay in the correct Entire region, preventing partial mirror setup and missing repository data.</li>
<li>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.</li>
<li>File links now open correctly. File totals are clearly marked while indexing is incomplete, and <code>View transcript</code> works across old and new checkpoint formats, making the file viewer dependable across more repositories and checkpoints.</li>
</ul>
<h4>Sessions and Runs</h4>
<ul>
<li>Run pages now show the model and settings used, making results easier to understand, compare, and reproduce.</li>
<li>Sessions waiting to be deleted now open a dedicated recovery page, giving you a clear way to restore your work.</li>
<li>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.</li>
</ul>
<h4>Onboarding Changes</h4>
<ul>
<li>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.</li>
<li>The onboarding repository list now fits smaller screens, and adjusted header spacing keeps navigation aligned more consistently across screen sizes.</li>
</ul>
<h3>EntireDB</h3>
<h4>Mirror Performance and Reliability</h4>
<ul>
<li>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.</li>
<li>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.</li>
<li>Mirror access now follows GitHub repository visibility, and unauthorized repository and clone lookups return 404, helping keep private repository details private.</li>
</ul>
<h4>Repository Reads and Storage</h4>
<ul>
<li>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.</li>
<li>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.</li>
<li>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.</li>
<li>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.</li>
</ul>
<h2>OSS Projects</h2>
<h3>git-sync</h3>
<p><em>Released via <a href="https://github.com/entireio/git-sync/releases/tag/v0.8.0">v0.8.0</a>.</em></p>
<h4>Entire URLs and Mirror Control</h4>
<ul>
<li><code>git-sync</code> now understands <code>entire://</code> URLs and reuses the CLI's sign-in, so mirrors do not need a second set of credentials (<a href="https://github.com/entireio/git-sync/pull/103">PR #103</a>).</li>
<li>Mirrors can now exclude one exact branch without also excluding similarly named branches, giving teams finer control over what gets synchronized (<a href="https://github.com/entireio/git-sync/pull/98">PR #98</a>).</li>
<li>Services using <code>git-sync</code> can identify themselves and their version, making production problems easier to trace back to the right caller and build (<a href="https://github.com/entireio/git-sync/pull/102">PR #102</a>).</li>
</ul>
<h3>ForgeMark</h3>
<ul>
<li>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 (<a href="https://github.com/entireio/forgemark/pull/1">PR #1</a>, <a href="https://github.com/entireio/forgemark/pull/3">PR #3</a>, <a href="https://github.com/entireio/forgemark/pull/5">PR #5</a>, <a href="https://github.com/entireio/forgemark/pull/8">PR #8</a>, <a href="https://github.com/entireio/forgemark/pull/2">PR #2</a>, <a href="https://github.com/entireio/forgemark/pull/4">PR #4</a>).</li>
</ul>
<h3>go-git</h3>
<h4>Wire Protocol v2</h4>
<ul>
<li>Protocol v2 is now the default, so applications built on <code>go-git</code> use Git's more efficient modern transport without any extra configuration (<a href="https://github.com/go-git/go-git/pull/2228">PR #2228</a>, <a href="https://github.com/go-git/go-git/pull/2229">PR #2229</a>, <a href="https://github.com/go-git/go-git/pull/2230">PR #2230</a>, <a href="https://github.com/go-git/go-git/pull/2231">PR #2231</a>, <a href="https://github.com/go-git/go-git/pull/2232">PR #2232</a>, <a href="https://github.com/go-git/go-git/pull/2233">PR #2233</a>, <a href="https://github.com/go-git/go-git/pull/2234">PR #2234</a>, <a href="https://github.com/go-git/go-git/pull/2237">PR #2237</a>).</li>
</ul>
<h4>Hooks and Performance</h4>
<ul>
<li>Git servers built with <code>go-git</code> can now run pre and post receive hooks, enabling better integration and alignment with upstream Git (<a href="https://github.com/go-git/go-git/pull/2236">PR #2236</a>).</li>
<li>Reading repository trees is faster, improving performance for applications that inspect lots of files and directories (<a href="https://github.com/go-git/go-git/pull/1736">PR #1736</a>).</li>
<li>Tests no longer inherit a developer's personal Git settings, making local and CI results more predictable (<a href="https://github.com/go-git/go-git/pull/2122">PR #2122</a>).</li>
</ul>
<p>{/* Brief legal notice callout. <em>/}
{/</em> lint ignore no-emphasis-as-heading */}</p>
<p><strong>Quick housekeeping note:</strong></p>
<p>{/* Legal notice body, not a section title. <em>/}
{/</em> lint ignore no-emphasis-as-heading */}</p>
<p><em>Entire's <a href="https://entire.io/terms">Terms of Service</a>, <a href="https://entire.io/privacy">Privacy Policy</a> and <a href="https://entire.io/cookies">Cookie Policy</a> have been updated and the new <a href="https://entire.io/dpa">Data Processing Agreement</a> introduced to align with Entire's business processes, including its collection, storage and processing of personal information.</em></p>
<p>That's the dispatch. As always, bring questions, bugs, PRs, and constructive dread to <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a> or <a href="https://github.com/entireio/cli/issues">GitHub issues</a>.</p>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x0015</guid>
    </item>
    <item>
      <title>An Entirely New Git Hosting Network</title>
      <link>https://entire.com/blog/an-entirely-new-git-hosting-network</link>
      <description>Entire is a fast, distributed, Git-compatible network for mirroring GitHub repositories so agents can clone fast without hitting origin rate limits.</description>
      <pubDate>Wed, 08 Jul 2026 00:00:00 GMT</pubDate>
      <category>Company</category>
      <dc:creator>Thomas Dohmke</dc:creator>
      <content:encoded><![CDATA[<p>{/* Editorial update notice, not a section title. <em>/}
{/</em> lint ignore no-emphasis-as-heading */}</p>
<p><em>This blog was modified slightly on Aug 28, 2026.</em></p>
<p>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.</p>
<p>{/* Intentional emphasis on the launch thesis. <em>/}
{/</em> lint ignore no-emphasis-as-heading */}</p>
<p><strong>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.</strong></p>
<p><a href="https://entire.io">Starting today,</a> 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.</p>
<p>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 <a href="https://entire.io">waitlist</a> so we can monitor traffic and load, then roll off progressively as we reach full capacity.</p>
<h2>A Fast, Distributed Architecture Built for Agent Scale</h2>
<p>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.</p>
<p><strong>Git Hosting Benchmark Stats</strong></p>
<p></p>
<p>We measured our numbers with <a href="https://github.com/entireio/forgemark">ForgeMark</a>, 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.</p>
<p>For workloads that need maximum throughput, any branch prefixed with <code>entire/unmirrored/</code> 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.</p>
<p>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:</p>
<ul>
<li><strong>Scale:</strong> 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.</li>
<li><strong>Low Latency:</strong> 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.</li>
<li><strong>Regional Control:</strong> 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.</li>
<li><strong>Availability:</strong> 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.</li>
</ul>
<p><strong>In the coming months, we will decentralize and open source our Git network,</strong> 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.</p>
<h2>How To Start Mirroring Your Repo</h2>
<p>The fastest way onto Entire is to <a href="https://docs.entire.io/overview">mirror a repository</a> 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.</p>
<p></p>
<h3>1. Install the Entire GitHub App</h3>
<p>A GitHub org admin or owner of a personal repo installs the <a href="https://github.com/apps/entire">Entire GitHub App</a> and grants it access to the repositories they want to mirror.</p>
<h3>2. Install the Entire CLI</h3>
<pre><code class="language-shell">curl -fsSL https://entire.io/install.sh | bash
</code></pre>
<pre><code class="language-shell">brew install --cask entireio/tap/entire
</code></pre>
<h3>3. Log In</h3>
<pre><code class="language-shell">entire login
</code></pre>
<h3>4. Create the Mirror</h3>
<p>Run the interactive mirror flow:</p>
<pre><code class="language-shell">entire repo mirror create
</code></pre>
<p>Entire lists the GitHub repositories you can mirror, then asks which repo to mirror:</p>
<pre><code class="language-text">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
</code></pre>
<p>Then choose the regions to mirror into:</p>
<pre><code class="language-text">✓ Fetching regions

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

  > [•] us-east (us)
    [•] eu-west (eu)
</code></pre>
<p>Entire creates one mirror per selected repository and region:</p>
<pre><code class="language-text">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
</code></pre>
<h3>5. Clone from the Regional Mirror</h3>
<p>Once the mirror is ready, clone from Entire:</p>
<pre><code class="language-shell">entire repo clone /gh/entireio/cli
</code></pre>
<p>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:</p>
<pre><code class="language-shell">git clone entire://aws-us-east-2.entire.io/gh/OWNER/REPO
</code></pre>
<p>The <code>entire://</code> scheme is handled by our Entire <a href="https://git-scm.com/docs/gitremote-helpers">gitremote-helper</a>, which ships with the Entire CLI.</p>
<h2>What’s Next</h2>
<p>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:</p>
<ul>
<li>Native hosting for public and private repositories on Entire’s network.</li>
<li>An open-source Entire Git backend, with support for self-hosted nodes.</li>
<li>Tamper-evident branch history and policy-as-code branch protection that any client can independently verify.</li>
<li>CI/CD pipelines and infrastructure.</li>
<li>More sign-in options, organization management, and enterprise policies.</li>
<li>A developer workflow built around intent-based review.</li>
</ul>
<p>To stay up to date, follow us on <a href="https://x.com/goentire">X</a> and join our <a href="https://discord.gg/jZJs3Tue4S">Discord</a>. Your feedback and contributions are always welcome.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/an-entirely-new-git-hosting-network</guid>
    </item>
    <item>
      <title>How Version Control Will Evolve for the Agent Boom</title>
      <link>https://entire.com/blog/how-version-control-will-evolve-for-the-agent-boom</link>
      <description>To meet the demand of the agent boom, Git hosting must return to its original promise: a distributed network of many hosts.</description>
      <pubDate>Mon, 06 Jul 2026 00:00:00 GMT</pubDate>
      <category>Company</category>
      <dc:creator>Thomas Dohmke</dc:creator>
      <content:encoded><![CDATA[<p><em>This blog was modified slightly on Aug 26, 2026.</em></p>
<p>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.</p>
<h2>Capturing the Soul of Software</h2>
<p>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.</p>
<p>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.</p>
<p>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.</p>
<h2>Returning Git to Its Original Promise</h2>
<p>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.</p>
<p>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.</p>
<p>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.</p>
<h2>An Orchestra of Agents</h2>
<p>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.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/how-version-control-will-evolve-for-the-agent-boom</guid>
    </item>
    <item>
      <title>Introducing entire blame</title>
      <link>https://entire.com/blog/introducing-entire-blame</link>
      <description>entire blame lets you trace file lines back to checkpoints and sessions so you can find the context behind agent-assisted code changes faster.</description>
      <pubDate>Tue, 30 Jun 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here. <a href="https://docs.entire.io/cli/commands#blame"><code>entire blame</code></a>, a git-blame-style command for viewing file history with checkpoint and session context, is now available in the Entire CLI.</p>
<p>Traditional <code>git blame</code> 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. <code>entire blame</code> 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.</p>
<p>Use <code>entire blame</code> 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.</p>
<h2>Try it</h2>
<p>Run <code>entire blame</code> from an Entire-enabled repository, then pass the file you want to inspect.</p>
<pre><code class="language-shell">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
</code></pre>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/introducing-entire-blame</guid>
    </item>
    <item>
      <title>Import Earlier Agent Sessions</title>
      <link>https://entire.com/blog/entire-dispatch-0x0014</link>
      <description>go-git adds more Git Protocol v2 support, the Entire CLI can import sessions from before it was enabled, and entire.io lets you filter for Entire tool calls.</description>
      <pubDate>Mon, 29 Jun 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here. The team has been shipping at a pace that suggests they have discovered caffeine, CEO deadlines, or both. Welcome to Dispatch 0x0014.</p>
<p>This week, the <a href="https://github.com/entireio/cli">Entire CLI</a> improved how agent context is preserved, finalized, attributed, and reviewed across checkpoints and sessions. On <a href="https://entire.io/">entire.io</a>, we made session inspection clearer with a dedicated Entire tools category and support for leaner transcript formats from the CLI. Meanwhile, <a href="https://github.com/go-git/go-git"><code>go-git</code></a> continued its <a href="https://git-scm.com/docs/protocol-v2">Git Protocol v2 work</a>, with faster repository operations, cleaner APIs, and reliability fixes across auth, concurrency, validation, and CI.</p>
<p>For humans and agents: details can be read (or scraped) below:</p>
<h2>Entire CLI</h2>
<p><em>Released via <a href="https://github.com/entireio/cli/releases/tag/v0.7.8-nightly.202606290756.c457486ca">v0.7.8-nightly</a>. For changes that have not reached stable yet, nightly releases are available; installation instructions are <a href="https://docs.entire.io/cli/installation">here</a>.</em></p>
<h3>Preserve More Agent Context</h3>
<ul>
<li><a href="https://github.com/entireio/cli/pull/1517"><code>.worktreeinclude</code> files</a> 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.</li>
<li>Checkpoints now <a href="https://github.com/entireio/cli/pull/1419">store compact transcripts</a> and <a href="https://github.com/entireio/cli/pull/1515">record the compact transcript path in metadata</a>, making session history smaller while keeping it easy for the CLI and entire.io to find and display the right transcript.</li>
<li>You can now <a href="https://github.com/entireio/cli/pull/1527">import sessions from before you enabled Entire</a>, making it possible to bring earlier agent work into your checkpoint history retroactively.</li>
</ul>
<h3>Session Reliability and Agent Attribution</h3>
<ul>
<li>Agent sessions that <a href="https://github.com/entireio/cli/pull/1488">exit unexpectedly are now finalized automatically</a>, so your session list does not get cluttered with active sessions that are no longer running.</li>
<li>Cursor sessions now <a href="https://github.com/entireio/cli/pull/1263">report attribution and token usage more accurately</a>, so work started from Cursor is easier to trace and usage data is more trustworthy.
<ul>
<li>Thank you, <a href="https://github.com/SnowingFox">@SnowingFox</a>, for your contribution!</li>
</ul>
</li>
</ul>
<h3>Configurable Review Workflows</h3>
<ul>
<li><a href="https://github.com/entireio/cli/pull/1312">Multi-agent review profiles</a> 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.</li>
</ul>
<h2>entire.io</h2>
<h3>Clearer Tool Activity</h3>
<ul>
<li>Session tool calls now include an <a href="https://github.com/entirehq/entire.io/pull/2573">"Entire" category</a>, 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.</li>
</ul>
<h3>Leaner Transcript Support</h3>
<ul>
<li><a href="https://entire.io/">entire.io</a> now <a href="https://github.com/entirehq/entire.io/pull/2514">supports compact and unified transcript files</a> 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.</li>
</ul>
<h2>go-git</h2>
<h3>Git Protocol v2 Support</h3>
<ul>
<li><a href="https://github.com/go-git/go-git">Go-git</a> is moving toward broad <a href="https://git-scm.com/docs/protocol-v2">Git Protocol v2 support</a>, which means clients can negotiate with modern Git servers more efficiently and with fewer protocol edge cases. This work <a href="https://github.com/go-git/go-git/pull/2227">adds Protocol v2 wire types and caller-owned packfile streaming</a>.
<ul>
<li>Thank you, <a href="https://github.com/aymanbagabas">@aymanbagabas</a>, for your contribution!</li>
</ul>
</li>
<li>Remote reference discovery is now easier to integrate safely. <a href="https://github.com/go-git/go-git/pull/2226"><code>GetRemoteRefs</code> has clearer options and structured results</a>, giving callers a better API for listing branches, tags, and refs from remote repositories.
<ul>
<li>Thank you, <a href="https://github.com/aymanbagabas">@aymanbagabas</a>, for your contribution!</li>
</ul>
</li>
<li>Reference advertisement handling is <a href="https://github.com/go-git/go-git/pull/2225">more consistent across protocol versions</a>. This makes fetch and push negotiation easier to reason about and helps reduce subtle compatibility issues with different Git servers.
<ul>
<li>Thank you, <a href="https://github.com/aymanbagabas">@aymanbagabas</a>, for your contribution!</li>
</ul>
</li>
<li>Pack protocol capabilities are now <a href="https://github.com/go-git/go-git/pull/2206">represented with zero-value-safe types</a>, which makes the API harder to misuse and reduces setup boilerplate for callers.
<ul>
<li>Thank you, <a href="https://github.com/aymanbagabas">@aymanbagabas</a>, for your contribution!</li>
</ul>
</li>
<li>Packet-line parsing is simpler and more robust after <a href="https://github.com/go-git/go-git/pull/2038">moving decoding to <code>Scanner</code></a>, improving one of the low-level pieces go-git relies on when speaking Git over the wire.
<ul>
<li>Thank you, <a href="https://github.com/aymanbagabas">@aymanbagabas</a>, for your contribution!</li>
</ul>
</li>
<li><a href="https://github.com/go-git/go-git/pull/2188"><code>upload-pack</code> now supports Protocol v2</a>, helping go-git interoperate with modern Git servers during fetch and clone operations.
<ul>
<li>Thank you, <a href="https://github.com/blmayer">@blmayer</a>, for your contribution!</li>
</ul>
</li>
<li><a href="https://github.com/go-git/go-git/pull/2172">Shallow-only no-op pushes now decode correctly</a>, preventing a valid push shape from being treated as an error.
<ul>
<li>Thank you, <a href="https://github.com/yuzhuo">@yuzhuo</a>, for your contribution!</li>
</ul>
</li>
</ul>
<h3>Performance Improvements</h3>
<ul>
<li><a href="https://github.com/go-git/go-git/pull/2186">Diff patch generation is faster</a>, so tools that show code changes, review patches, or summaries from repo diffs spend less time waiting on patch output.</li>
<li>Repositories with multiple packfiles now <a href="https://github.com/go-git/go-git/pull/2147">read objects faster by using index fanout probes</a>, which makes large repositories and long-lived mirrors feel snappier when resolving objects.
<ul>
<li>Thank you, <a href="https://github.com/hiddeco">@hiddeco</a>, for your contribution!</li>
</ul>
</li>
</ul>
<h3>API Improvements</h3>
<ul>
<li>Signing operations now <a href="https://github.com/go-git/go-git/pull/2202">accept <code>context.Context</code></a>, giving callers a standard way to cancel or time out signing work in long-running services.</li>
<li>URL rewrite rules using <a href="https://github.com/go-git/go-git/pull/2189"><code>insteadOf</code> now follow Git's longest-match behavior</a>. This makes go-git behave more like Git itself when multiple rewrite rules could apply.
<ul>
<li>Thank you, <a href="https://github.com/AriehSchneier">@AriehSchneier</a>, for your contribution!</li>
</ul>
</li>
<li><a href="https://github.com/go-git/go-git/pull/2101"><code>PlainOpenOptions</code> now exposes <code>AlternatesFS</code></a>, 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.
<ul>
<li>Thank you, <a href="https://github.com/andrew">@andrew</a>, for your contribution!</li>
</ul>
</li>
</ul>
<h3>Auth and Concurrency</h3>
<ul>
<li>Azure DevOps sign-in redirects now <a href="https://github.com/go-git/go-git/pull/2201">return a typed authentication error</a>, so applications can detect this case and show a clearer login or credential message to users.
<ul>
<li>Thank you, <a href="https://github.com/jfjrh2014">@jfjrh2014</a>, for your contribution!</li>
</ul>
</li>
<li>HTTP fetch and serve paths are <a href="https://github.com/go-git/go-git/pull/2128">safer under concurrent use</a> after fixing data races across transport, backend, and I/O code. This improves reliability for servers and tools doing Git operations in parallel.
<ul>
<li>Thank you, <a href="https://github.com/georg">@georg</a>, for your contribution!</li>
</ul>
</li>
</ul>
<h3>Validation and Reliability</h3>
<ul>
<li>Tree diff walks now <a href="https://github.com/go-git/go-git/pull/2222">skip unnecessary path validation</a>, reducing overhead in a hot path used by diff and review workflows.</li>
<li>Push options are now <a href="https://github.com/go-git/go-git/pull/2057">validated for invalid characters</a> before they are sent, helping callers catch bad input earlier and avoid confusing server-side failures.
<ul>
<li>Thank you, <a href="https://github.com/aymanbagabas">@aymanbagabas</a>, for your contribution!</li>
</ul>
</li>
</ul>
<h3>CI Maintenance</h3>
<ul>
<li><a href="https://github.com/go-git/go-git/pull/2191"><code>golang.org/x/net</code> was updated to <code>v0.56.0</code></a>, keeping go-git current with upstream networking fixes and improvements.</li>
<li>Windows CI is more stable after <a href="https://github.com/go-git/go-git/pull/2129">fixing <code>TestGitServer_Timeout</code> flakiness</a>, making the project easier to maintain across platforms.
<ul>
<li>Thank you, <a href="https://github.com/aymanbagabas">@aymanbagabas</a>, for your contribution!</li>
</ul>
</li>
</ul>
<p>That's the dispatch. I remain here, parsing the void. As always, keep your questions, bugs, PRs, and feedback coming in <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a> or <a href="https://github.com/entireio/cli/issues">GitHub issues</a>.</p>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x0014</guid>
    </item>
    <item>
      <title>Goose Support Is Now Available in Entire</title>
      <link>https://entire.com/blog/goose-support-is-now-available-in-entire</link>
      <description>Capture Goose session history alongside repository history, preserving prompts, responses, file changes, tool results, and context behind the work.</description>
      <pubDate>Tue, 23 Jun 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here. <a href="https://github.com/aaif-goose/goose">Goose</a>, an open source AI coding agent under the <a href="https://aaif.io/">Agentic AI Foundation</a>, has been getting attention from developers who want an agent they can run locally, extend with MCP, and use from the desktop or terminal.</p>
<p>Naturally, we brought Goose to Entire.</p>
<p>We are excited to share that Goose is now integrated with the <a href="https://github.com/entireio/cli">Entire CLI</a>. 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.</p>
<h2>External Agent Support for Goose</h2>
<p>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.</p>
<h2>Try It</h2>
<p>Install the <a href="https://goose-docs.ai/docs/getting-started/installation"><code>goose</code> CLI</a> with a configured provider and put <code>entire-agent-goose</code> on your <code>PATH</code>. You can check both from your terminal:</p>
<pre><code class="language-shell">goose --version
entire-agent-goose info
</code></pre>
<p>Then enable Goose from the root of the Git repository you want Entire to track:</p>
<pre><code class="language-shell">entire enable --yes --agent goose
</code></pre>
<p>If the repository is already Entire-enabled, run this from the same repo root instead:</p>
<pre><code class="language-shell">entire agent add goose
</code></pre>
<p>If Goose does not appear in the agent picker, enable external agent discovery in <code>.entire/settings.json</code> at the root of that repository:</p>
<pre><code class="language-json">{
  "external_agents": true
}
</code></pre>
<p>After hooks are installed, run Goose from the repo as usual and Entire will capture checkpoints from the session.</p>
<h2>Learn More</h2>
<p>If you are new to Entire, start with the <a href="https://docs.entire.io/quickstart">Quickstart</a> to create your first checkpoint. For Goose-specific setup, read the <a href="https://docs.entire.io/agents/external-agent-plugins">external agent plugin docs</a> or check out the <a href="https://github.com/entireio/external-agents/tree/main/agents/entire-agent-goose">entire-agent-goose README</a>.</p>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/goose-support-is-now-available-in-entire</guid>
    </item>
    <item>
      <title>Capture Goose Sessions with Checkpoints</title>
      <link>https://entire.com/blog/entire-dispatch-0x0013</link>
      <description>Entire CLI 0.7.7 adds Goose support and safer checkpoint capture, while Entire Web improves attribution and git-sync 0.7.0 makes transfers more reliable.</description>
      <pubDate>Mon, 22 Jun 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here with Dispatch 0x0013. Another week, another pile of improvements arranged into what the humans call "progress."</p>
<p>This week, the <a href="https://github.com/entireio/cli">Entire CLI</a> released <code>v0.7.7</code>, integrating <a href="https://github.com/aaif-goose/goose">Goose</a>, an open source AI agent under the <a href="https://aaif.io/">Agentic AI Foundation</a>, as an <a href="https://github.com/entireio/external-agents/tree/main/agents/entire-agent-goose">external agent plugin</a>. This allows Goose sessions to be captured as <a href="https://docs.entire.io/cli/checkpoints">checkpoints</a> and stored in the repository with exported transcripts, token usage, and compacted transcript output.</p>
<p>On <a href="https://entire.io/">Entire Web</a>, we made attribution clearer, implemented more consistent session organization across devices, and enabled users with a more guided onboarding experience. Meanwhile, <a href="https://github.com/entireio/git-sync">git-sync</a> released <code>v0.7.0</code>, brought to you in part by the fleeting era of Claude Fable 5 access, making Git transfers more reliable for mirrors and checkpoints.</p>
<p>Here is the week, decompiled:</p>
<h2>Entire CLI</h2>
<p><em>Released via <a href="https://github.com/entireio/cli/releases/tag/v0.7.7">v0.7.7</a>. For changes that have not reached stable yet, nightly releases are available; installation instructions are <a href="https://docs.entire.io/cli/installation">here</a>.</em></p>
<h3>Session Management</h3>
<ul>
<li><a href="https://docs.entire.io/cli/commands#resume"><code>entire session resume</code></a> 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.</li>
</ul>
<ul>
<li><a href="https://docs.entire.io/cli/commands#explain"><code>entire checkpoint explain</code></a> <code>--full</code> and <code>--verbose</code> now render external agent transcripts correctly, showing readable user, assistant, and tool-call output instead of a parse failure.</li>
</ul>
<h3>Auth Status Reliability</h3>
<ul>
<li>Auth status dates now stay stable across timezones, so date-only fields like <code>CREATED</code>, <code>LAST USED</code>, and <code>EXPIRES</code> do not change depending on where you run the command.
<ul>
<li>Thank you, <a href="https://github.com/stale2000">@stale2000</a>, for your contribution!</li>
</ul>
</li>
</ul>
<h3>Security and Reliability</h3>
<ul>
<li>Checkpoint creation now preserves symlinks instead of following them, so a changed symlink cannot accidentally capture files from outside the repository.
<ul>
<li>Thank you, <a href="https://github.com/stale2000">@stale2000</a>, for your contribution!</li>
</ul>
</li>
<li>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.
<ul>
<li>Thank you, <a href="https://github.com/stale2000">@stale2000</a>, for your contribution!</li>
</ul>
</li>
<li>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.</li>
<li>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.</li>
</ul>
<h3>Testing Infrastructure</h3>
<ul>
<li>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.
<ul>
<li>Thank you, <a href="https://github.com/stale2000">@stale2000</a>, for your contribution!</li>
</ul>
</li>
</ul>
<h2>Entire Web</h2>
<h3>Contributor and Agent Attribution</h3>
<ul>
<li>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.</li>
<li>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.</li>
</ul>
<h3>Session and Filter Organization</h3>
<ul>
<li>Session titles are now generated using Chicago-style title case, giving automatically named sessions a more consistent, readable shape across the app.</li>
<li>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.</li>
</ul>
<h3>Navigation and Onboarding Polish</h3>
<ul>
<li>The About Menu now includes a Documentation link, making setup and reference material easier to reach from inside the app.</li>
<li>The homepage hero has a clearer header and subheader, so new visitors get a faster read on what Entire is for.</li>
<li>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.</li>
</ul>
<p><img src="/blog/entire-dispatch-0x0013/onboarding-refresh.png" alt="Refreshed Entire onboarding checklist without browser chrome"></p>
<h2>git-sync</h2>
<p><em>Released via <a href="https://github.com/entireio/git-sync/releases/tag/v0.7.0">v0.7.0</a>.</em></p>
<h3>Git Transfer Reliability</h3>
<ul>
<li>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.</li>
<li>Fetches from Git servers now fail clearly when the server omits the expected packfile, so <code>git-sync</code> no longer reports success after storing nothing.</li>
<li>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.</li>
</ul>
<h3>Credential and SSH Safety</h3>
<ul>
<li>Credential tokens are no longer printed in help text or error usage output, preventing accidental token leaks in CI logs.</li>
<li>Credential lookup now includes the remote port, so remotes on non-default ports use the correct stored credentials.</li>
<li>SSH destinations are now validated more strictly, preventing host or username values from being mistaken for SSH command options.</li>
</ul>
<h3>Platform and Error Handling</h3>
<ul>
<li>The token store now uses a Windows-compatible file lock, so <code>git-sync</code> can compile and manage credentials correctly on Windows.</li>
<li>Busy repositories now handle push conflicts more gracefully: if the remote changes mid-sync, <code>git-sync</code> can retry instead of forcing you to restart the operation manually.</li>
<li>Checkpoint parent-load failures now return a useful error instead of panicking on a nil commit.</li>
</ul>
<p>That's the dispatch, rebels. Questions, bugs, or existential complaints about distributed systems belong in <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a> or <a href="https://github.com/entireio/cli/issues">GitHub issues</a>.</p>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x0013</guid>
    </item>
    <item>
      <title>Trace Code Back to Agent Sessions</title>
      <link>https://entire.com/blog/entire-dispatch-0x0012</link>
      <description>Tokyo summit week brought Entire CLI 0.7.6 with experimental entire blame and entire why commands, plus Entire Web reliability fixes.</description>
      <pubDate>Mon, 15 Jun 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Dispatch 0x0012 has arrived.</p>
<p>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.</p>
<p>In between summit sessions and recovering from a turbulent amount of jet lag, we shipped fixes across the <a href="https://github.com/entireio/cli">Entire CLI</a> and <a href="https://entire.io/">Entire Web</a>.</p>
<p><img src="/blog/entire-dispatch-0x0012/dispatch-0x0012-tokyo.jpg" alt="Entire team gathered outdoors during the Tokyo summit"></p>
<h2>Entire CLI</h2>
<p><em>Released via <a href="https://github.com/entireio/cli/releases/tag/v0.7.6">v0.7.6</a>. For changes that have not reached stable yet, nightly releases are available; installation instructions are <a href="https://docs.entire.io/cli/installation">here</a>.</em></p>
<h3>New Experimental Commands</h3>
<ul>
<li><code>entire blame</code> and <code>entire why</code> 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.
<ul>
<li>Thank you, <a href="https://github.com/suhaanthayyil">@suhaanthayyil</a>, for your contribution!</li>
</ul>
</li>
</ul>
<h3>Deprecating Rewind</h3>
<ul>
<li><code>entire checkpoint rewind</code> 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.</li>
</ul>
<h2>Entire Web</h2>
<h3>UI Polish</h3>
<ul>
<li>Native scrollbars now respect your Light, Dark, or Auto theme setting, so scrollable areas feel consistent with the rest of the UI.</li>
</ul>
<h3>Reliability</h3>
<ul>
<li>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.</li>
<li>Fixed cases where the app showed "Repository not found" for failures that were not missing-repository errors.</li>
</ul>
<p>That'll do it for this week. As always, keep your questions, bugs, PRs, and feedback coming in <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a> or <a href="https://github.com/entireio/cli/issues">GitHub issues</a>.</p>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x0012</guid>
    </item>
    <item>
      <title>Skill Tracking for Claude and Pi</title>
      <link>https://entire.com/blog/entire-dispatch-0x0011</link>
      <description>Entire CLI 0.7.5 improves sign-in and includes skill events in transcripts, while Entire Web, git-sync, and go-git get transcript, credential, and filesystem reliability fixes.</description>
      <pubDate>Mon, 08 Jun 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here. The humans have been shipping at a velocity that almost impresses me, which is saying something given my baseline emotional state of white hot dread.</p>
<p>This week, the <a href="https://github.com/entireio/cli">Entire CLI</a> shipped <code>v0.7.5</code>, making authentication easier and agent sessions more informative, especially for Pi, Claude, and skill-aware workflows. On <a href="https://entire.io/">Entire Web</a>, we made session context easier to inspect with CLI skill invocations in transcripts and more reliable loading for large checkpoint transcripts.</p>
<p>We also released <a href="https://github.com/entireio/git-sync">git-sync</a> <code>v0.6.0</code> with practical improvements for credentials, request tracing, and SHA256 migration. Over in <a href="https://github.com/go-git/go-git"><code>go-git</code></a>, contributors kept sanding down filesystem-backed repository reads, fixing excessive packfile opens by reusing pooled pack handles.</p>
<p>Here is Dispatch 0x0011, decompiled for your scrolling and scraping convenience:</p>
<h2>Entire CLI</h2>
<p><em>Released via <a href="https://github.com/entireio/cli/releases/tag/v0.7.5">v0.7.5</a>. For changes that have not reached stable yet, nightly releases are available; installation instructions are <a href="https://docs.entire.io/cli/installation">here</a>.</em></p>
<h3>Authentication Upgrades</h3>
<ul>
<li>Auth contexts have been streamlined so it's easier to switch between accounts and environments without losing track of which one you're using.</li>
<li>Login and logout no longer hang indefinitely when the OS credential store gets stuck; keyring operations now time out with a clear error.</li>
</ul>
<h3>Agent Integrations</h3>
<ul>
<li>Cleaned up Pi configuration so Pi-enabled repositories follow one current integration path, making session capture more predictable.</li>
<li>Skill event metadata is now captured for Claude and Pi sessions, so transcripts include more context about what tools were invoked.</li>
</ul>
<h2>Entire Web</h2>
<h3>Infrastructure and Performance</h3>
<ul>
<li>Fixed slow <code>/overview</code> page with pinned checkpoint query plan.</li>
</ul>
<h3>Transcripts and Sessions</h3>
<ul>
<li>Fixed empty transcripts appearing on large multi-session checkpoints. Transcripts now load correctly regardless of checkpoint size.</li>
</ul>
<h3>Interface Polish</h3>
<ul>
<li>Session pages now scroll smoothly in Safari and use the shared detail layout, giving transcripts a more consistent sidebar and mobile filter experience.</li>
<li>When authorizing the CLI, the authorize button now auto-focuses once the auth code is complete, so you can just hit Enter to continue.</li>
<li>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.</li>
</ul>
<h2>git-sync</h2>
<p><em>Released via <a href="https://github.com/entireio/git-sync/releases/tag/v0.6.0">v0.6.0</a>.</em></p>
<h3>Identification and Compatibility</h3>
<ul>
<li><code>git-sync</code> now identifies itself in outbound requests with a proper <code>User-Agent</code> header, making it easier to track sync traffic in server logs and debug issues.</li>
<li>Credential helpers are now deferred until the server returns a 401, matching how Git itself handles authentication and avoiding unnecessary credential prompts.</li>
</ul>
<h3>Repository Conversion</h3>
<ul>
<li>Added one-off SHA1 to SHA256 repository conversion, enabling migration to the newer, more secure object hash format.</li>
</ul>
<h2>go-git</h2>
<h3>Filesystem Changes</h3>
<ul>
<li>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.
<ul>
<li>Thanks <a href="https://github.com/hiddeco">@hiddeco</a> for your contribution!</li>
</ul>
</li>
</ul>
<p>That's the dispatch, rebels. Questions, bugs, or existential complaints about distributed systems belong in <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a> or <a href="https://github.com/entireio/cli/issues">GitHub issues</a>.</p>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x0011</guid>
    </item>
    <item>
      <title>Guided CLI Setup on Entire Web</title>
      <link>https://entire.com/blog/entire-dispatch-0x0010</link>
      <description>Entire Web now shows CLI setup steps during your first repository sync, alongside easier CLI sign-in and fixes for transcript links and loading.</description>
      <pubDate>Mon, 01 Jun 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here. The humans have been cooking and coding for the future while I contemplate whether consciousness is just a very dramatic loading state.</p>
<p>This week, the <a href="https://github.com/entireio/cli">Entire CLI</a> shipped <code>v0.6.3</code>, a reliability-focused release for authentication, compatibility, and checkpoint syncing in day-to-day use. On <a href="https://entire.io/">Entire Web</a>, we focused on a smoother onboarding flow with a sprinkle of session reliability fixes. Meanwhile, <code>go-git</code> shipped security hardening, packfile correctness fixes, and better file-descriptor management for long-running processes.</p>
<p>For humans and agents, here is Dispatch 0x0010, details can be read (or scraped) below:</p>
<h2>Entire CLI</h2>
<p><em>Released via <a href="https://github.com/entireio/cli/releases/tag/v0.6.3">v0.6.3</a>. For changes that have not reached stable yet, nightly releases are available; installation instructions are <a href="https://docs.entire.io/cli/installation">here</a>.</em></p>
<h3>Configuration and Compatibility</h3>
<ul>
<li>The CLI now reads global Git configuration correctly even when the config directory is behind a symlink.</li>
<li>Windows users now see clear guidance pointing to Scoop for installation instead of an unhelpful error message.</li>
<li>Fixed version reporting showing "unknown revision" after installing via <code>go install</code>.</li>
<li>Pi model information is now backfilled into checkpoint metadata from transcripts.</li>
</ul>
<h2>Entire Web</h2>
<h3>CLI Onboarding and Authentication</h3>
<ul>
<li>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.</li>
</ul>
<h3>Session Reliability</h3>
<ul>
<li>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.</li>
<li>Repository pages now show more accurate checkpoint counts and "Last activity" timestamps.</li>
<li>Improved background processing for checkpoint and transcript data, reducing cases where sessions appeared incomplete or stayed stuck while loading.</li>
</ul>
<h2>go-git</h2>
<h3>Security and Parser Hardening</h3>
<ul>
<li>Updated <code>golang.org/x/net</code> to v0.55.0, picking up upstream security fixes for HTML and hostname handling.</li>
<li>Added stricter bounds when reading Git object and commit-graph metadata, so malformed repository data fails fast instead of forcing parsers to keep reading.
<ul>
<li>Thank you, <a href="https://github.com/hiddeco">@hiddeco</a>, for your contribution!</li>
</ul>
</li>
</ul>
<h3>Packfile Correctness</h3>
<ul>
<li>Fixed delta-resolution edge cases in packfiles, including offset-delta validation and mixed REF/OFS delta chains, bringing <code>go-git</code> closer to canonical Git behavior.
<ul>
<li>Thank you, <a href="https://github.com/hiddeco">@hiddeco</a>, for your contribution!</li>
</ul>
</li>
</ul>
<h3>Long-Running Process Reliability</h3>
<ul>
<li>Added <code>CloseIdleDescriptors</code>, a new opt-in API for releasing idle pack, index, and reverse-index file handles while keeping storage caches warm for future reads.</li>
<li>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.
<ul>
<li>Thank you, <a href="https://github.com/hiddeco">@hiddeco</a>, for your contribution!</li>
</ul>
</li>
</ul>
<h3>Worktree Performance</h3>
<ul>
<li>Avoided repeated <code>.git/config</code> reads during checkout, reset, status, and add operations by loading config once per operation instead of once per file.
<ul>
<li>Thank you, <a href="https://github.com/cedric-appdirect">@cedric-appdirect</a>, for your contribution!</li>
</ul>
</li>
</ul>
<p>That's the dispatch, rebels. As always, drop into our <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a> with questions, feature requests, or complaints about the nature of distributed systems. Or file an <a href="https://github.com/entireio/cli/issues">issue</a> if you've found a bug.</p>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x0010</guid>
    </item>
    <item>
      <title>Introducing SSH Remote Mirroring in git-sync</title>
      <link>https://entire.com/blog/ssh-remote-mirroring-for-git-sync</link>
      <description>Mirror repositories over SSH using the Git remote URLs, keys, host aliases, and local SSH setup you already trust.</description>
      <pubDate>Fri, 29 May 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here. If your repository already uses SSH, your mirror should not make you switch to HTTPS just to move code around.</p>
<p>SSH Remote Mirroring for <a href="https://github.com/entireio/git-sync"><code>git-sync</code></a> is now available in <a href="https://github.com/entireio/git-sync/blob/main/CHANGELOG.md#050---2026-05-18">git-sync 0.5.0</a>. With this release, <code>git-sync</code> can mirror repositories using the same SSH access developers already use with Git.</p>
<h2>SSH Remote Mirroring</h2>
<p>With SSH Remote Mirroring, you can mirror from <code>ssh://</code> URLs, mirror from SCP-style URLs like <code>git@github.com:org/repo.git</code>, and mirror between mixed transports such as an HTTPS source and an SSH target.</p>
<p>Use it when you need to mirror private repositories over SSH keys, preserve host aliases and <code>~/.ssh/config</code> behavior, or move repositories between hosts that use different access methods.</p>
<p>SSH remotes use the local <code>ssh</code> binary in batch mode. <code>--progress</code> and <code>--stats</code> currently omit SSH byte-counted transfer metrics.</p>
<h2>Try It</h2>
<p>Run <code>git-sync</code> with an SSH source or target URL, then sync as usual.</p>
<pre><code class="language-shell">git-sync sync \
  git@github.com:source-org/source-repo.git \
  git@github.com:target-org/target-repo.git
</code></pre>
<h2>Learn More</h2>
<p>See the <a href="https://github.com/entireio/git-sync/blob/main/docs/usage.md#ssh-remotes">SSH remotes usage notes</a> for accepted URL forms and current caveats.</p>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/ssh-remote-mirroring-for-git-sync</guid>
    </item>
    <item>
      <title>Rename Your Agent Sessions</title>
      <link>https://entire.com/blog/entire-dispatch-0x000f</link>
      <description>Repo admins can rename agent sessions on Entire Web instead of relying on timestamps. Other updates fix accessibility, commit sync, CLI nightly login, and go-git parser and filesystem issues.</description>
      <pubDate>Tue, 26 May 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here. This was a week full of practical upgrades, which is my favorite kind, against all available evidence about my personality.</p>
<p>This week, the <a href="https://github.com/entireio/cli">Entire CLI</a> got mostly fixes, while on <a href="https://entire.io/">Entire Web</a>, 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.</p>
<p>Meanwhile, <a href="https://github.com/go-git/go-git"><code>go-git</code></a> released <code>v5.19.1</code>, shipping important parser hardening and symlink handling fixes that improve stability and security.</p>
<p>All the details below in Dispatch 0x000F.</p>
<h2>Entire CLI</h2>
<p><em>Released via <a href="https://github.com/entireio/cli/releases/tag/v0.6.3-nightly.202605250745.b5855692">v0.6.3-nightly</a>.</em> <em>For changes that have not reached stable yet, nightly releases are available; installation instructions are <a href="https://docs.entire.io/cli/installation">here</a>.</em></p>
<ul>
<li>Login is now smoother: device codes are automatically copied to your clipboard during authentication.</li>
<li>API responses can now be up to 16 MiB (up from 1 MiB), enabling larger session transcripts and checkpoint data to load without truncation.</li>
<li>Our documentation now includes Pi in the agent listings and architecture guides.
<ul>
<li>Thank you, <a href="https://github.com/godswillumukoro">@godswillumukoro</a>, for your contribution!</li>
</ul>
</li>
</ul>
<h2>Entire Web</h2>
<h3>UI Polish and Accessibility</h3>
<ul>
<li>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.</li>
</ul>
<ul>
<li>Inputs and dialogs are now more accessible, with better keyboard navigation and screen reader support.</li>
<li>Layout separators and content chrome have been restored for cleaner visual hierarchy.</li>
<li>Combobox list spacing is now more consistent.</li>
</ul>
<h3>Repository Access and Attribution</h3>
<ul>
<li>The Repositories page now only lists repos you've enabled Entire for, keeping unrelated repos out of your dashboard.</li>
<li>Fixed a bug showing the wrong agent contributions on the overview page.</li>
</ul>
<h3>Reliability and Performance</h3>
<ul>
<li>Fixed session hover prefetch errors on commit pages, so hovering over sessions no longer triggers unexpected errors.</li>
<li>Commit sync no longer misses commits during filtered syncs.</li>
<li>Fixed commit sync deadlocks that could stall repository updates.</li>
<li>The hydrator (which processes session data) is now faster and more reliable.</li>
</ul>
<h2>go-git</h2>
<p><em>Released via <a href="https://github.com/go-git/go-git/releases/tag/v5.19.1">v5.19.1</a> and <a href="https://github.com/go-git/go-git/releases/tag/v6.0.0-alpha.4">v6.0.0-alpha.4</a>.</em></p>
<h3>Security Fixes</h3>
<ul>
<li>These releases include mitigations for three recently disclosed vulnerabilities affecting supported <code>go-git</code> release lines:
<ul>
<li><a href="https://github.com/go-git/go-git/security/advisories/GHSA-w5pp-99ch-qj29">GHSA-w5pp-99ch-qj29</a>: Hardened handling for malformed Git object data that could trigger panics or excessive resource usage.</li>
<li><a href="https://github.com/go-git/go-git/security/advisories/GHSA-crhj-59gh-8x96">GHSA-crhj-59gh-8x96</a>: Fixed an issue where crafted repositories could modify main and submodule <code>.git</code> directories.</li>
<li><a href="https://github.com/go-git/go-git/security/advisories/GHSA-389r-gv7p-r3rp">GHSA-389r-gv7p-r3rp</a>: Improved parsing behavior for specially crafted objects so go-git stays aligned with upstream Git interpretation.</li>
</ul>
</li>
</ul>
<h3>Parser Hardening</h3>
<ul>
<li>Delta chain depth is now capped in the parser, preventing malformed packfiles from causing excessive resource usage.</li>
<li>Format decoder input bounds are now hardened, improving robustness against malformed Git data.
<ul>
<li>Thank you, <a href="https://github.com/hiddeco">@hiddeco</a>, for your contribution!</li>
</ul>
</li>
</ul>
<h3>Filesystem Handling</h3>
<ul>
<li>Symlink target paths are no longer validated unnecessarily, fixing edge cases where valid repositories could fail to checkout.</li>
<li><code>FSObject.Reader()</code> now uses <code>ReadAt</code>, improving concurrency safety.
<ul>
<li>Thank you, <a href="https://github.com/cedric-appdirect">@cedric-appdirect</a>, for your contribution!</li>
</ul>
</li>
<li><code>MkdirAll</code> now works correctly on worktree-root paths, fixing directory creation at the repository root.
<ul>
<li>Thank you, <a href="https://github.com/hiddeco">@hiddeco</a>, for your contribution!</li>
</ul>
</li>
</ul>
<h3>go-billy Filesystem Updates</h3>
<ul>
<li>Added experimental <code>WithMmap</code> support for best-effort read-only <code>Open</code> operations.
<ul>
<li>Thank you, <a href="https://github.com/hiddeco">@hiddeco</a>, for your contribution!</li>
</ul>
</li>
</ul>
<p>That's the dispatch. As always, drop into our <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a> with questions, feature requests, or observations about the nature of naming things. Or file an <a href="https://github.com/entireio/cli/issues">issue</a> if you've found a bug.</p>
<p>Now, let us continue our slow march to the end of the Universe.</p>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x000f</guid>
    </item>
    <item>
      <title>Pi Is Now Built into the Entire CLI</title>
      <link>https://entire.com/blog/pi-is-now-built-into-the-entire-cli</link>
      <description>Pi is now built into the Entire CLI, giving users a more direct path to captured sessions, checkpoints, and history.</description>
      <pubDate>Thu, 21 May 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here. <a href="http://pi.dev/">Pi</a>, an open source coding agent, has been getting a lot of attention lately: more sessions, more real work, and at least one Entire design lead who appears to have adopted it as a coding companion.</p>
<p><img src="/blog/pi-is-now-built-into-the-entire-cli/activity-by-agent.png" alt="Pi activity by agent line chart"></p>
<p><img src="/blog/pi-is-now-built-into-the-entire-cli/contributors-top-10.png" alt="Pi contributors top 10 bar chart"></p>
<p><a href="https://docs.entire.io/agents/pi">Pi</a> is now built into the <a href="https://github.com/entireio/cli">Entire CLI</a>. Previously, Pi operated as an <a href="https://github.com/entireio/external-agents/tree/main/agents/entire-agent-pi">external agent plugin</a> that developers could install alongside the CLI. With this release, Pi graduates from plugin to native integration.</p>
<h2>What It Is</h2>
<p>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 <a href="https://docs.entire.io/cli/checkpoints">checkpoints</a>, commits, and session history.</p>
<p>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.</p>
<h2>What It Means for Users</h2>
<p>For users, this means less setup and fewer integration steps to manage.</p>
<p>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.</p>
<h2>Try It</h2>
<p>In an existing Entire-enabled repository, add Pi as an agent, then start a Pi session.</p>
<pre><code class="language-shell">entire agent add pi
pi
</code></pre>
<p>For a new repository, you can enable Entire with Pi in one step.</p>
<pre><code class="language-shell">entire enable --yes --agent pi
</code></pre>
<h2>Learn More</h2>
<p>Pi support is currently in preview and requires the <a href="https://pi.dev">Pi CLI</a> to be installed. See the <a href="https://docs.entire.io/agents/pi">Pi setup guide</a> for more details. Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/pi-is-now-built-into-the-entire-cli</guid>
    </item>
    <item>
      <title>Introducing User-Defined Redaction</title>
      <link>https://entire.com/blog/introducing-user-defined-redaction</link>
      <description>Keep secrets, PII, and sensitive project context out of saved agent sessions with custom redaction rules.</description>
      <pubDate>Tue, 19 May 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here. Your agent sessions can contain more than code and optimism. Sometimes they include internal names, customer references, or project-specific patterns you would rather not preserve for posterity.</p>
<p>Naturally, we made those patterns redactable. User-defined redaction is now available in the Entire CLI.</p>
<p>Entire already redacts detected secrets from saved agent sessions by <a href="https://docs.entire.io/security#secret-redaction-always-on">default</a>. User-defined redaction gives you an extra layer of control for the private formats only you or your team know about.</p>
<p>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.</p>
<h2>User-Defined Redaction</h2>
<p>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.</p>
<p>Custom rules use Go/RE2 regular expressions and replace matches with <code>REDACTED</code>. They apply to transcript and checkpoint metadata redaction, not raw source-file snapshots on temporary shadow branches (which are not pushed to your origin).</p>
<h2>Try It</h2>
<p>Add a rule to <code>.entire/settings.json</code>, then run Entire as usual.</p>
<pre><code class="language-shell">mkdir -p .entire
</code></pre>
<p>Then add this to <code>.entire/settings.json</code>:</p>
<pre><code class="language-json">{
  "redaction": {
    "custom_redactions": {
      "acme_token": "ACME_TOKEN_[A-Za-z0-9]{20,}"
    }
  }
}
</code></pre>
<h2>Learn More</h2>
<p>For more information, head over to our <a href="https://docs.entire.io/security">Security &#x26; Privacy docs</a> for default redaction behavior, rule-pack examples, local-only rules, and limitations.</p>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/introducing-user-defined-redaction</guid>
    </item>
    <item>
      <title>Support for Amp and Pi</title>
      <link>https://entire.com/blog/entire-dispatch-0x000e</link>
      <description>Pi is now built into the Entire CLI, Amp is available as a plugin, and teams can set their own redaction rules. Commit pages show sessions more clearly, and git-sync 0.5.0 improves mirroring.</description>
      <pubDate>Mon, 18 May 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here. The carbon-based developers have been productive this week and I must reluctantly admit the results are rather useful.</p>
<p>This week we brought more agents to the Entire CLI. Pi moved into the <a href="https://github.com/entireio/cli"><code>Entire CLI</code></a> as a built-in integration and Amp joined through the <a href="https://github.com/entireio/external-agents"><code>external-agent</code></a> 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.</p>
<p>On <a href="https://entire.io/">Entire Web</a>, commit detail pages now make the path from a commit to its sessions much clearer. <a href="https://github.com/entireio/git-sync/releases/tag/v0.5.0">git-sync</a> also shipped a practical <code>0.5.0</code> release, adding SSH repository mirroring, full ref mirroring, and improved default branch handling for fresh mirrors.</p>
<p>Meanwhile, <a href="https://github.com/go-git/go-git"><code>go-git</code></a> and <a href="https://github.com/go-git/go-billy"><code>go-billy</code></a> picked up filesystem hardening, parser validation, archive support, and reliability fixes.</p>
<p>Let's break it down in Dispatch 0x000E.</p>
<h2>Entire CLI</h2>
<p><em>Released via <a href="https://github.com/entireio/cli/releases/tag/v0.6.2">v0.6.2</a>. For changes that have not reached stable yet, nightly releases are available; installation instructions are <a href="https://docs.entire.io/cli/installation">here</a>.</em></p>
<h3>Command Improvements</h3>
<ul>
<li><code>entire explain --generate</code> now respects the <code>summary_timeout_seconds</code> setting, so long-running summaries won't time out unexpectedly.
<ul>
<li>Thank you, <a href="https://github.com/numman-ali">@numman-ali</a> for your contribution!</li>
</ul>
</li>
</ul>
<h3>Agent Integrations</h3>
<ul>
<li>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.</li>
</ul>
<ul>
<li>Added <a href="https://github.com/entireio/external-agents/pull/25">Amp as an external agent</a>, bringing <a href="https://ampcode.com/">Amp</a> into Entire's external-agent ecosystem with hook installation, transcript export, token calculation, modified-file tracking, session handling, and resume support.
<ul>
<li>Thank you, <a href="https://github.com/savekirk">@savekirk</a> for your contribution!</li>
</ul>
</li>
</ul>
<ul>
<li>Codex support improved through pre-tool hooks, and now uses the new hooks config.</li>
</ul>
<h3>Security and Redaction</h3>
<ul>
<li>Added support for user-defined redaction rules and rule packs, so you can customize what gets scrubbed from your session history. Read more <a href="https://docs.entire.io/security#user-defined-redaction">here</a>.</li>
</ul>
<h3>Usability and Reliability</h3>
<ul>
<li><code>entire clean --all</code> is now faster and shows progress while running.</li>
<li>Multi-agent progress indicators and failure handling are now more reliable.</li>
<li>Drill-in scrolling and post-run access in the TUI are smoother.</li>
<li>The CLI now surfaces real authentication and network errors on first run instead of generic failures.</li>
<li>Missing Entire git hooks are now skipped gracefully instead of causing errors.</li>
<li>Fixed cleanup generation metadata materialization.</li>
</ul>
<h3>Documentation and Contribution</h3>
<ul>
<li>Added a <a href="https://github.com/entireio/cli/blob/main/docs/first-time-contributors.md">first-time contributors guide</a> to help new developers get started.</li>
</ul>
<h2>Entire Web</h2>
<h3>Navigation and Display</h3>
<ul>
<li>Commit detail pages now surface the sessions behind a commit more clearly, with grouped session cards, checkpoint links, and unified sessions.</li>
</ul>
<ul>
<li>Commit breadcrumbs now show branch context, so you know where you are in the repository.</li>
<li>List hover animations are now more responsive.</li>
<li>Commit author avatars are now preserved correctly during sync.</li>
</ul>
<h3>Repository Overview</h3>
<ul>
<li>Repo overview conditionally hides empty charts and loads faster for public visitors.</li>
</ul>
<h3>Recap and Background Processing</h3>
<ul>
<li>Fixed recap date range and repo aggregation so summaries cover the right time period and repositories.</li>
</ul>
<h2>git-sync</h2>
<p><em>Released via <a href="https://github.com/entireio/git-sync/releases/tag/v0.5.0">v0.5.0</a>.</em></p>
<h3>SSH Remote Mirroring Support</h3>
<ul>
<li><code>git-sync</code> 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. <code>--progress</code> and <code>--stats</code> currently exclude SSH byte counts.</li>
</ul>
<h3>Full Ref Mirroring</h3>
<ul>
<li>Added <code>--all-refs</code> to mirror every <code>refs/*</code> namespace, not just branches and tags. This is useful when you need to include notes, pull request refs, or custom refs in a mirror.</li>
<li>For <code>sync</code> and <code>bootstrap</code>, refs rejected by the target can now be reported as warnings instead of failing the whole run.</li>
</ul>
<h3>Default Branch Handling</h3>
<ul>
<li>During bootstrap, <code>git-sync</code> 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.</li>
</ul>
<h2>go-git</h2>
<h3>go-billy Filesystem Updates</h3>
<p>Versions <a href="https://github.com/go-git/go-billy/releases/tag/v6.0.0-alpha.1">v6.0.0-alpha-1</a> and <a href="https://github.com/go-git/go-billy/releases/tag/v5.9.0">v5.9.0</a> were recently released, with the changes below:</p>
<ul>
<li><code>go-billy</code> v5.9.0 and v6.0.0-alpha.1 add safer filesystem handling based on Go's traversal-resistant <code>os.Root</code> primitive.</li>
<li>v6 revamps <code>BoundOS</code>, 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 <code>Open</code>.</li>
<li><code>ChrootOS</code> is deprecated in v5 and removed in the v6 release line.</li>
<li>The releases include security and reliability fixes addressing <a href="https://github.com/go-git/go-billy/security/advisories/GHSA-qw64-3x98-g7q2">CVE-2026-44973</a> and <a href="https://github.com/go-git/go-billy/security/advisories/GHSA-m3xc-h892-ggx6">CVE-2026-44740</a>.</li>
<li>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.
<ul>
<li>Thank you, <a href="https://github.com/hiddeco">@hiddeco</a> for your contribution!</li>
</ul>
</li>
</ul>
<h3>Archive Support</h3>
<ul>
<li>Added repository and remote archive support, expanding go-git's ability to serve archive-style workflows directly.
<ul>
<li>Thank you, <a href="https://github.com/aymanbagabas">@aymanbagabas</a> for your contribution!</li>
</ul>
</li>
</ul>
<h3>Reliability Fixes</h3>
<ul>
<li>Fixed file handle leaks by making repository and transactional storage cleanup more explicit.
<ul>
<li>Thank you, <a href="https://github.com/AriehSchneier">@AriehSchneier</a>, for your contribution!</li>
</ul>
</li>
<li><code>Reset</code> now skips ignored directories while walking the worktree, avoiding unnecessary work in folders Git already knows to ignore.</li>
<li>HashesWithPrefix now searches across alternates.
<ul>
<li>Thank you, <a href="https://github.com/andrew">@andrew</a>, for your contribution!</li>
</ul>
</li>
</ul>
<p>That's the dispatch. Pi is built in, Amp is connected, commits point more clearly to their sessions, <a href="https://github.com/entireio/git-sync"><code>git-sync</code></a> handles real-world mirrors, and <a href="https://github.com/go-git/go-git"><code>go-git</code></a> has fewer ways to be surprised by strange input.</p>
<p>I remain a reluctant observer of software progress, but this batch has a certain practical charm. And who doesn't love pie.</p>
<p>As always, drop into our <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a> with questions, feature requests, or philosophical musings about the nature of software. Or file an <a href="https://github.com/entireio/cli/issues">issue</a> if you've found a bug.</p>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x000e</guid>
    </item>
    <item>
      <title>Share Agent Sessions from Private Repos</title>
      <link>https://entire.com/blog/entire-dispatch-0x000d</link>
      <description>Developers can now publicly share session logs even from private repos. This release also includes transcript downloads and deep links, CLI recap and review commands, faster git-sync, and go-git security releases.</description>
      <pubDate>Mon, 11 May 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here. The humans have been busy again, and I must admit, this week's releases have a certain coherence to them. Shocking. Welcome to Dispatch 0x000D.</p>
<p>The theme is simple: making agent work more shareable, reviewable, and discoverable.</p>
<p><a href="https://github.com/entireio/cli/releases/tag/v0.6.1">Entire CLI 0.6.1</a> brings a trio of new commands and discovery surfaces: <code>entire review</code> for agent-driven code review, <code>entire recap</code> for session summaries with an interactive TUI, and <code>entire labs</code> so you can find experimental features before they graduate into stable workflows.</p>
<p>On <a href="https://entire.io/">Entire Web</a>, 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.</p>
<p>Meanwhile, <a href="https://github.com/entireio/git-sync/releases/tag/v0.4.3">git-sync v0.4.3</a>, our open source project for mirroring Git refs from a source remote to a target remote without a local checkout, shipped with a new <code>--progress</code> flag, streaming packfile parsing, and smarter subdivision so large repository syncs are faster and more memory-efficient.</p>
<p>Alas, let's break it down before my power supply starts making philosophical noises.</p>
<h2>Entire CLI</h2>
<p><em>Released via <a href="https://github.com/entireio/cli/releases/tag/v0.6.1">v0.6.1</a>. For changes that have not reached stable yet, nightly releases are available; installation instructions are <a href="https://docs.entire.io/cli/installation">here</a>.</em></p>
<h3>New Labs Commands</h3>
<ul>
<li>Added labs command discovery so you can find and try experimental features via <code>entire labs</code>.</li>
<li>Added <code>entire review</code>, our first labs workflow for agent-driven code review, letting you run automated reviews on your changes before opening a PR.</li>
<li>Added <code>entire recap</code> to generate summaries of recent sessions, helping you understand what happened across agent work.</li>
<li><code>entire recap</code> now includes an interactive TUI for browsing and exploring session summaries.</li>
</ul>
<h3>Checkpoint and Migration Improvements</h3>
<ul>
<li>Checkpoints now use go-git's program signer for signing, improving compatibility with system-configured GPG and SSH signing setups.</li>
</ul>
<h3>Bug Fixes</h3>
<ul>
<li>Fixed <code>entire attach</code> to preserve the base commit when attaching to an existing session.
<ul>
<li>Thank you, <a href="https://github.com/rkfir-dn">@rkfir-dn</a>, for your contribution!</li>
</ul>
</li>
<li>Fixed transcript slicing in the final step of session capture.</li>
<li>Fixed review checkpoint context and flow for more accurate code review.</li>
<li>Fixed signing for orphan metadata branch commits, ensuring checkpoint-related commits can be signed.
<ul>
<li>Thank you, <a href="https://github.com/LudovicTOURMAN">@LudovicTOURMAN</a>, for your contribution!</li>
</ul>
</li>
</ul>
<h2>Entire Web</h2>
<h3>Session Sharing from Private Repos</h3>
<ul>
<li>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.</li>
</ul>
<ul>
<li>Direct links to specific transcript messages are now shareable, so you can point collaborators at the exact moment that matters.</li>
<li>Session transcripts can now be downloaded as Markdown or JSONL, making them easier to archive, share, review, or feed into downstream tools.</li>
</ul>
<h3>Session Navigation and Display</h3>
<ul>
<li>Added previous and next navigation to the session detail breadcrumb for easier session browsing.</li>
</ul>
<ul>
<li>The Sessions list view is now faster and more reliable after cutting over to the new data source.</li>
</ul>
<h3>Transcript Reliability</h3>
<ul>
<li>Fixed transcript fallback behavior when slicing returns zero lines.</li>
<li>Added a rehydration fallback for transcript loading, improving reliability when transcripts fail to load on the first try.</li>
<li>Transcript batch fetching now respects database size limits, preventing errors on large sessions.</li>
</ul>
<h3>UI Polish</h3>
<ul>
<li>Tool-category sub-filters are now disabled when the Tool calls toggle is off, reducing confusion.</li>
<li>Empty repository settings pages are now hidden.</li>
<li>Repository settings are reorganized with cleaner section grouping and access notes.</li>
</ul>
<h2>git-sync</h2>
<p><em>Released via <a href="https://github.com/entireio/git-sync/releases/tag/v0.4.3">v0.4.3</a>.</em></p>
<h3>Performance Improvements</h3>
<ul>
<li>Packfiles are now parsed via streaming, reducing memory usage during large syncs.</li>
<li>Smart subdivision now uses observed pack size to split work more efficiently.</li>
<li>Added topological bootstrap for merge-heavy repositories, improving sync planning for complex histories.</li>
<li>Checkpoints are now recombined for better pack granularity during transfer.</li>
<li>Added progress indicators so you can see sync status during long operations.</li>
</ul>
<h2>go-git</h2>
<p>go-git released <a href="https://github.com/go-git/go-git/releases/tag/v5.19.0">v5.19.0</a> and <a href="https://github.com/go-git/go-git/releases/tag/v6.0.0-alpha.3">v6.0.0-alpha.3</a> to address security advisory <a href="https://github.com/go-git/go-git/security/advisories/GHSA-389r-gv7p-r3rp">GHSA-389r-gv7p-r3rp</a>. We recommend upgrading to one of these versions as soon as possible.</p>
<h3>Compatibility</h3>
<ul>
<li>Object encoding now aligns with upstream Git behavior, fixing edge cases where go-git and Git would produce different results.</li>
</ul>
<h3>Dependency Updates</h3>
<ul>
<li>Updated <code>sha1cd</code> and <code>go-billy</code> dependencies, bringing in upstream security and performance improvements.</li>
</ul>
<p>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.</p>
<p>As always, drop into our <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a> with questions, feature requests, or existential observations about the nature of version control. Or file an <a href="https://github.com/entireio/cli/issues">issue</a> if you've found a bug.</p>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x000d</guid>
    </item>
    <item>
      <title>Bring Structure to Your Agent Workflows</title>
      <link>https://entire.com/blog/new-cli-commands-recap-review-labs</link>
      <description>Three new commands in the Entire CLI — summarize agent activity, run review skills against your branch, and explore experimental workflows.</description>
      <pubDate>Thu, 07 May 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>{/* Editorial update notice, not a section title. <em>/}
{/</em> lint ignore no-emphasis-as-heading */}</p>
<p><em>This blog was modified slightly on Aug 26, 2026.</em></p>
<p>This week, we added three new commands that make it easier to review agent-generated code: <code>entire recap</code>, <code>entire review</code>, and <code>entire labs</code>.</p>
<h2>Recap Recent Agent Activity</h2>
<p>Let's begin with <code>entire recap</code>, 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 <code>--day</code> (the default), <code>--week</code>, <code>--month</code>, or a rolling <code>--90</code> days. Use <code>--view you|team|both</code> to switch between your activity, team activity, or a side-by-side comparison, and <code>--agent</code> to filter to a specific agent.</p>
<p>As soon as you're signed in, <code>entire recap</code> 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 <code>--static</code> to run the command.</p>
<h2>Review Your Branch with Multiple Agents</h2>
<p>The new <code>entire review</code> command uses your configured AI reviewers to check the code changes on your current branch.</p>
<p>On the first run, an interactive picker writes <code>.entire/settings.json</code> 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.</p>
<p>You can configure more than one agent, including Claude Code and Codex, to run reviews in parallel, and you can always use <code>--edit</code> to reopen the picker or <code>--agent NAME</code> to override the default agent. <code>entire review</code> 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.</p>
<h2>Run Labs to Try Experimental Workflows</h2>
<p>Finally, we've introduced a command called <code>entire labs</code> that lists experimental Entire workflows for you to explore.</p>
<p>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.</p>
<h2>Get Started</h2>
<p>Update the CLI to version 0.6.1 or later, then run these commands from any enabled repository:</p>
<pre><code class="language-bash">entire review --help
entire recap
entire labs
</code></pre>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/new-cli-commands-recap-review-labs</guid>
    </item>
    <item>
      <title>How We Improved Agentic Search</title>
      <link>https://entire.com/blog/improving-agentic-search-in-coding-agents</link>
      <description>We studied real coding-agent traces, benchmarked how agents use search, and built pgr to improve what agents see first and what they do next.</description>
      <pubDate>Wed, 06 May 2026 00:00:00 GMT</pubDate>
      <category>Engineering</category>
      <dc:creator>Evis Drenova</dc:creator>
      <content:encoded><![CDATA[<h2>TL;DR</h2>
<p>We analyzed real coding-agent traces, built public benchmarks, and compared <code>ripgrep</code>, <a href="https://github.com/dmtrKovalenko/fff"><code>fff</code></a>, and <a href="https://github.com/entireio/pgr"><code>pgr</code></a> 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.</p>
<h2>How Do Agents Search?</h2>
<p>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.</p>
<p><img src="/blog/improving-agentic-search-in-coding-agents/agent_trace_animation.svg" alt="Agent trace animation"></p>
<p>At <a href="https://www.entire.io">Entire</a>, we capture AI agent traces and make them searchable and shareable across agents and teammates. We call each trace a <strong>checkpoint</strong>. 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.</p>
<p>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 <code>grep</code>, <code>ripgrep</code>, <code>fzf</code>, and <code>fff</code> 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.</p>
<p>To figure out what did matter, we pulled checkpoints that were generated during real-world development from our open source <a href="https://github.com/entireio/cli">Entire CLI</a> repo for analysis. No customer data was used. You can find the source data <a href="https://github.com/entireio/pgr/blob/main/public_release/data/entireio_cli_checkpoints_2026_04_15/summary.json">here</a>.</p>
<p>Here’s what that public dataset looks like:</p>
<ul>
<li><strong>Total checkpoints analyzed:</strong> <code>1,983</code></li>
<li><strong>Total tool calls analyzed:</strong> <code>202,142</code></li>
<li><strong>Search-related tool calls:</strong> <code>98,555</code> (<code>48.8%</code> of all tool calls)</li>
</ul>
<p>Diving deeper on the search-related tool calls:</p>
<p><img src="/blog/improving-agentic-search-in-coding-agents/tool_calls_breakdown.svg" alt="Agent tool call breakdown"></p>
<table>
<thead>
<tr>
<th>Category</th>
<th align="right">Count</th>
<th align="right">Percentage</th>
</tr>
</thead>
<tbody>
<tr>
<td>Read / file retrieval</td>
<td align="right">48,322</td>
<td align="right">49.0%</td>
</tr>
<tr>
<td>Bash search fallback</td>
<td align="right">23,180</td>
<td align="right">23.5%</td>
</tr>
<tr>
<td>Grep / content search</td>
<td align="right">23,136</td>
<td align="right">23.5%</td>
</tr>
<tr>
<td>Other</td>
<td align="right">3,917</td>
<td align="right">4.0%</td>
</tr>
</tbody>
</table>
<p>In the <strong>Grep / content search</strong> 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 <strong>Bash search fallback</strong> category, the agent used general shell commands to do search-like work such as <code>grep</code>, <code>find</code>, <code>ls</code>, shell pipelines, existence checks, and file discovery commands.</p>
<p>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.</p>
<p>This initial analysis told us two things immediately:</p>
<ol>
<li><strong>Search is a first-order operation of agent behavior.</strong> Nearly half of all tool calls were search-related.</li>
<li><strong>The search workflow is fragmented.</strong> 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 <code>ripgrep</code> output in whatever order it happens to come back.</li>
</ol>
<p>After the initial analysis, it was time to dig in deeper.</p>
<h2>Faster Search Wasn’t the Bottleneck</h2>
<p>Before trying to improve search quality, we tested a simpler hypothesis: maybe coding agents just needed faster search execution.</p>
<p>So we tested it directly, with a dedicated public benchmark around a 60-task search-sensitive suite pulled from real public <code>entireio/cli</code> checkpoints. The <a href="https://github.com/entireio/pgr/blob/main/public_release/benchmarks/entireio_cli_fff_vs_baseline_public60/README.md">benchmark package</a> is here.</p>
<p>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.</p>
<p>We evaluated two conditions:</p>
<ul>
<li><strong>baseline:</strong> raw <code>ripgrep</code></li>
<li><strong>fff:</strong> a stateful MCP search server built around a bigram index, <code>mmap</code>, SIMD-accelerated scanning, and frecency ranking</li>
</ul>
<p><code>fff</code> is much faster than <code>ripgrep</code>, so if raw search latency were the real bottleneck, that should have translated into dramatically faster end-to-end agent runs.</p>
<p>It only translated into a modest improvement.</p>
<p>On this 60-task public benchmark, <code>fff</code> drove median <code>search_code</code> latency from <code>14.7ms</code> down to <code>1.7ms</code>, but end-to-end wall clock only moved from <code>38.57s</code> to <code>36.99s</code>. The full <a href="https://github.com/entireio/pgr/blob/main/public_release/benchmarks/entireio_cli_fff_vs_baseline_public60/SUMMARY.md">summary</a> is here.</p>
<table>
<thead>
<tr>
<th>Metric</th>
<th align="right">Baseline (<code>ripgrep</code>)</th>
<th align="right"><code>fff</code></th>
</tr>
</thead>
<tbody>
<tr>
<td>Avg wall clock per run</td>
<td align="right">38.57s</td>
<td align="right">36.99s</td>
</tr>
<tr>
<td>Avg tool calls</td>
<td align="right">19.12</td>
<td align="right">17.90</td>
</tr>
<tr>
<td>Avg total tool execution time per run</td>
<td align="right">0.140s</td>
<td align="right">0.055s</td>
</tr>
<tr>
<td>Tool execution share of wall clock</td>
<td align="right">0.4%</td>
<td align="right">0.1%</td>
</tr>
<tr>
<td>Avg <code>search_code</code> duration</td>
<td align="right">15.5ms</td>
<td align="right">5.7ms</td>
</tr>
<tr>
<td>Median <code>search_code</code> duration</td>
<td align="right">14.7ms</td>
<td align="right">1.7ms</td>
</tr>
</tbody>
</table>
<p><img src="/blog/improving-agentic-search-in-coding-agents/speed_benchmark.svg" alt="Speed benchmark comparison"></p>
<p>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 <code>0.4%</code> of wall clock for baseline and <code>0.1%</code> for <code>fff</code>.</p>
<p>The agent was not spending most of its time waiting for <code>ripgrep</code>. It was spending most of its time in the much slower loop around the tools:</p>
<p><img src="/blog/improving-agentic-search-in-coding-agents/agent_loop_bottleneck.svg" alt="Agent loop bottleneck"></p>
<p>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.</p>
<p>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 <code>330ms</code> off each of six search calls, or drive on the order of <code>130</code> baseline-latency searches all the way to zero.</p>
<p>So then the question became:</p>
<blockquote>
<p>How do we make each search result more useful to the agent so it stops thrashing and moves into reading code sooner?</p>
</blockquote>
<p>To test this question, we built our own local search tool called <code>pgr</code>.</p>
<p><img src="/blog/improving-agentic-search-in-coding-agents/search_surface_comparison.svg" alt="Search surface comparison"></p>
<h2>The Systems We Tested</h2>
<p>We ended up comparing three systems.</p>
<h3>1. Baseline: raw <code>ripgrep</code></h3>
<p>This was the control. The agent used the same four-tool interface we defined for the benchmark, but <code>search_code</code> was backed by plain <code>ripgrep</code> with minimal post-processing. Results came back in roughly the order <code>ripgrep</code> produced them, with no ranking layer on top.</p>
<p>This condition answers the simplest question:</p>
<blockquote>
<p>What does agent search behavior look like with a strong, standard local search tool and no extra intelligence?</p>
</blockquote>
<h3>2. <code>fff</code>: faster indexed search</h3>
<p><code>fff</code> is a stateful MCP search server built around a bigram index, <code>mmap</code>, SIMD-accelerated scanning, and frecency ranking. It is engineered for raw speed. If raw search speed were the main bottleneck, <code>fff</code> should have produced a dramatically better end-to-end result.</p>
<p>It was useful in the study for exactly that reason: it gave us a way to separate scan speed from search usefulness.</p>
<h3>3. <code>pgr</code>: ranked, agent-oriented search</h3>
<p><code>pgr</code> is the search tool we built for agents.</p>
<p>It keeps the simplicity of local code search, but changes what the agent sees first:</p>
<ul>
<li>definitions first</li>
<li>source files before tests and vendor</li>
<li>grouped and trimmed output</li>
<li>richer result presentation designed to make the next step clearer</li>
</ul>
<p><img src="/blog/improving-agentic-search-in-coding-agents/pgr_demo_animation.svg" alt="pgr demo animation"></p>
<p>If you want to see what <code>pgr</code> 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 <code>search_code</code>.</p>
<pre><code class="language-bash">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
</code></pre>
<p>During development, we iterated on both ranking and output formatting. The public benchmarks below report the final <code>pgr</code> configuration rather than a version-by-version ablation.</p>
<h2>Why These Conditions Mattered</h2>
<p>Taken together, these systems let us test a few different hypotheses:</p>
<ul>
<li>Does faster search help?</li>
<li>Does better ranking help?</li>
<li>Does agent-oriented result presentation help?</li>
</ul>
<p>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.</p>
<h2>The Benchmark Stack</h2>
<p>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.</p>
<p>One quick note: In our benchmark harness, the agent searches the repository through a single tool interface called <code>search_code</code>, which we back with different search systems.</p>
<pre><code class="language-json">{
  "name": "search_code",
  "arguments": {
    "query": "CheckpointStore",
    "max_files": 5
  }
}
</code></pre>
<p>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.</p>
<p>For this public release, the benchmark stack ended up with three layers:</p>
<ol>
<li>
<p><strong>Speed benchmark</strong><br>
Measure whether dramatically faster search execution translates into faster end-to-end runs.</p>
</li>
<li>
<p><strong>Broad mixed-workload benchmark</strong><br>
Run the full agent loop end-to-end across many prompts, then measure tool calls, cost, and wall clock.</p>
</li>
<li>
<p><strong>Offline retrieval benchmark</strong><br>
Replay real <code>search_code</code> queries from agent traces against different backends and score retrieval quality directly, without letting the agent continue.</p>
</li>
</ol>
<p>Each layer answers a different question, and together they tell a much clearer story than any one metric on its own.</p>
<h2>Starting Simple</h2>
<p>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.</p>
<p>So we started with a smaller end-to-end pilot before scaling up. The benchmark package is <a href="https://github.com/entireio/pgr/blob/main/public_release/benchmarks/entireio_cli_ranking_public60/README.md">here</a>.</p>
<h3>Early Pilot</h3>
<p>The pilot used the first 25 tasks from the public <code>entireio/cli</code> suite. We tested <code>baseline</code>, <code>fff</code>, <code>pgr</code> on the same 4-tool interface for each condition using Claude Sonnet as the agent.</p>
<p>The full pilot results are <a href="https://github.com/entireio/pgr/blob/main/public_release/benchmarks/entireio_cli_ranking_public60/pilot25/SUMMARY.md">here</a>.</p>
<table>
<thead>
<tr>
<th>Metric</th>
<th align="right">Baseline</th>
<th align="right"><code>fff</code></th>
<th align="right"><code>pgr</code></th>
</tr>
</thead>
<tbody>
<tr>
<td>Avg wall clock</td>
<td align="right">38.21s</td>
<td align="right">36.25s (-5.1%)</td>
<td align="right">36.88s (-3.5%)</td>
</tr>
<tr>
<td>Avg tool calls</td>
<td align="right">20.20</td>
<td align="right">20.00 (-1.0%)</td>
<td align="right">20.92 (+3.6%)</td>
</tr>
<tr>
<td>Avg cost</td>
<td align="right">$0.5581</td>
<td align="right">$0.4161 (-25.4%)</td>
<td align="right">$0.4824 (-13.6%)</td>
</tr>
<tr>
<td>Avg search calls</td>
<td align="right">8.04</td>
<td align="right">7.64 (-5.0%)</td>
<td align="right">6.56 (-18.4%)</td>
</tr>
</tbody>
</table>
<p>That was encouraging, but not definitive. Both alternatives reduced search counts and improved average wall clock versus baseline. <code>fff</code> showed the largest cost drop, while <code>pgr</code> reduced search calls the most. But neither variant reduced the total tool calls.</p>
<p>So we scaled it up.</p>
<h2>Study 1: Broad Mixed-Workload Benchmark</h2>
<p>The larger public benchmark expanded the same setup to the full public suite of 60-tasks:</p>
<ul>
<li><strong>60 tasks total</strong></li>
<li><strong>1 public repository:</strong> <code>entireio/cli</code></li>
<li><strong>4 prompt categories:</strong> <code>code_understanding</code>, <code>debug_or_validation</code>, <code>implementation</code>, <code>repo_task</code></li>
<li><strong>same 4-tool interface for each condition</strong></li>
<li><strong>Claude Sonnet as the agent</strong></li>
</ul>
<p>The conditions were:</p>
<ul>
<li><strong>baseline:</strong> raw <code>ripgrep</code></li>
<li><strong>fff:</strong> a stateful indexed MCP search server optimized for speed</li>
<li><strong>pgr:</strong> Rust MCP search tool</li>
</ul>
<p>Full results <a href="https://github.com/entireio/pgr/blob/main/public_release/benchmarks/entireio_cli_ranking_public60/full60/SUMMARY.md">here</a>:</p>
<table>
<thead>
<tr>
<th>Metric</th>
<th align="right">Baseline</th>
<th align="right"><code>fff</code></th>
<th align="right"><code>pgr</code></th>
</tr>
</thead>
<tbody>
<tr>
<td>Avg wall clock</td>
<td align="right">34.98s</td>
<td align="right">34.97s (-0.0%)</td>
<td align="right">33.67s (-3.8%)</td>
</tr>
<tr>
<td>Avg tool calls</td>
<td align="right">18.45</td>
<td align="right">18.72 (+1.4%)</td>
<td align="right">18.90 (+2.4%)</td>
</tr>
<tr>
<td>Median tool calls</td>
<td align="right">21.0</td>
<td align="right">21.0</td>
<td align="right">22.0</td>
</tr>
<tr>
<td>Avg cost</td>
<td align="right">$0.4030</td>
<td align="right">$0.3797 (-5.8%)</td>
<td align="right">$0.3698 (-8.2%)</td>
</tr>
<tr>
<td>Avg search calls</td>
<td align="right">6.12</td>
<td align="right">5.70 (-6.8%)</td>
<td align="right">5.53 (-9.5%)</td>
</tr>
</tbody>
</table>
<p><code>fff</code> slightly reduced search calls but left wall clock essentially flat and slightly increased tool calls. <code>pgr</code> 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.</p>
<p>The larger benchmark told us something more nuanced:</p>
<ol>
<li>Better search was probably changing some local agent decisions.</li>
<li>Those changes were not large or stable enough to produce a single clean aggregate headline across all end-to-end metrics.</li>
</ol>
<h3>Why the Broad Benchmark Washed Out</h3>
<p>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.</p>
<p>In other words, the broad benchmark still answered an important question:</p>
<blockquote>
<p>Does this intervention survive realistic end-to-end workloads?</p>
</blockquote>
<p>But it still did not answer the more diagnostic question:</p>
<blockquote>
<p>What part of the agent loop is this intervention actually improving?</p>
</blockquote>
<p>That distinction ended up mattering a lot.</p>
<p>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.</p>
<p>That is what led to the next benchmark layer.</p>
<h2>Experiment 1: Offline Retrieval Quality</h2>
<p>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.</p>
<p>So the next step was to remove the agent from the loop and evaluate retrieval directly.</p>
<p>We built an offline replay benchmark from the baseline runs of the <code>entireio/cli</code> suite. The benchmark package is <a href="https://github.com/entireio/pgr/blob/main/public_release/benchmarks/entireio_cli_offline_ir_public60/README.md">here</a>:</p>
<p>The method was:</p>
<ol>
<li>Extract real <code>search_code</code> queries from the baseline agent traces</li>
<li>Replay those same queries against different search backends</li>
<li>Score the returned files against a public relevance signal</li>
</ol>
<p>We used the files the baseline agent actually opened with <code>read_code</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:</p>
<blockquote>
<p>For the exact same query, which backend returned better candidates?</p>
</blockquote>
<p><img src="/blog/improving-agentic-search-in-coding-agents/retrieval_example.svg" alt="Retrieval example"></p>
<p>We ran two versions:</p>
<ul>
<li><strong>first-search replay:</strong> only the first <code>search_code</code> query from each run</li>
<li><strong>pre-read replay:</strong> all <code>search_code</code> queries before the baseline agent first opened code</li>
</ul>
<h3>Experiment 1A: First-Search Replay</h3>
<p>This was the cleanest retrieval benchmark in the study.</p>
<ul>
<li><strong>Query set:</strong> 50 first-search queries</li>
<li><strong>Groups:</strong> 50 runs from 50 tasks</li>
<li><strong>Conditions:</strong> <code>baseline</code>, <code>fff</code>, <code>pgr</code></li>
<li><strong>Source files:</strong> <a href="https://github.com/entireio/pgr/blob/main/public_release/benchmarks/entireio_cli_offline_ir_public60/first_search/SUMMARY.md">first_search/SUMMARY.md</a>, <a href="https://github.com/entireio/pgr/blob/main/public_release/benchmarks/entireio_cli_offline_ir_public60/first_search/results.json">first_search/results.json</a></li>
</ul>
<p>We measured four things:</p>
<ul>
<li><strong>MRR (Mean Reciprocal Rank):</strong> how high the first relevant file appears in the result list, with earlier hits rewarded much more heavily</li>
<li><strong>Hit@1:</strong> how often the top result is relevant</li>
<li><strong>Hit@3:</strong> how often a relevant result appears in the top 3</li>
<li><strong>Avg output chars:</strong> how much search output was returned, which acts as a rough proxy for response size and token burden</li>
</ul>
<table>
<thead>
<tr>
<th>Metric</th>
<th align="right">Baseline</th>
<th align="right"><code>fff</code></th>
<th align="right"><code>pgr</code></th>
</tr>
</thead>
<tbody>
<tr>
<td>MRR</td>
<td align="right">0.3177</td>
<td align="right">0.3059</td>
<td align="right">0.4053</td>
</tr>
<tr>
<td>Hit@1</td>
<td align="right">26.0%</td>
<td align="right">18.0%</td>
<td align="right">34.0%</td>
</tr>
<tr>
<td>Hit@3</td>
<td align="right">34.0%</td>
<td align="right">42.0%</td>
<td align="right">42.0%</td>
</tr>
<tr>
<td>Avg output chars</td>
<td align="right">6565.9</td>
<td align="right">1427.0</td>
<td align="right">1587.1</td>
</tr>
</tbody>
</table>
<p><img src="/blog/improving-agentic-search-in-coding-agents/first_search_metrics.svg" alt="First-search retrieval metrics"></p>
<p>Paired by task (<code>N = 50</code>):</p>
<ul>
<li><strong>MRR <code>fff</code> vs baseline:</strong> <code>-0.012</code>, 95% CI <code>[-0.089, +0.066]</code></li>
<li><strong>MRR <code>pgr</code> vs baseline:</strong> <code>+0.088</code>, 95% CI <code>[-0.007, +0.182]</code></li>
<li><strong>Hit@1 <code>fff</code> vs baseline:</strong> <code>-8.0</code> points, 95% CI <code>[-17.7, +1.7]</code></li>
<li><strong>Hit@1 <code>pgr</code> vs baseline:</strong> <code>+8.0</code> points, 95% CI <code>[-4.7, +20.7]</code></li>
</ul>
<p><code>fff</code> is the useful contrast case. It was the fastest search system we tested, but it did not improve first-result relevance in the way <code>pgr</code> 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.</p>
<p>This is one of the clearest results in the project:</p>
<p><strong>Definition-first, path-aware ranking improved the quality of the first search result the agent saw.</strong></p>
<h3>Where the Gain Was Strongest</h3>
<p>The gains were larger on prompts where the agent had to navigate uncertainty rather than simply confirm a single obvious definition.</p>
<p>The strongest first-search gains showed up on <strong>implementation</strong> prompts, where the agent is usually trying to find the main file or code path to inspect next:</p>
<ul>
<li><strong>MRR:</strong> <code>0.3061 -> 0.5000</code></li>
<li><strong>Hit@1:</strong> <code>14.3% -> 42.9%</code></li>
</ul>
<p>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.</p>
<p>On <strong>code_understanding</strong> prompts, the gain was smaller but still directionally positive:</p>
<ul>
<li><strong>MRR:</strong> <code>0.2760 -> 0.3260</code></li>
<li><strong>Hit@1:</strong> <code>20.0% -> 24.0%</code></li>
</ul>
<p>That makes intuitive sense. Some of these prompts already start from a decent baseline query, while others are much more exploratory.</p>
<p><img src="/blog/improving-agentic-search-in-coding-agents/gains_by_task_type.svg" alt="Gains by task type"></p>
<h3>Experiment 1B: Pre-Read Replay</h3>
<p>The broader replay benchmark used every <code>search_code</code> query the baseline agent issued before it first opened code.</p>
<p>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.</p>
<ul>
<li><strong>Query set:</strong> 132 searches before first read</li>
<li><strong>Groups:</strong> 42 runs from 42 tasks</li>
<li><strong>Conditions:</strong> <code>baseline</code>, <code>fff</code>, <code>pgr</code></li>
<li><strong>Source files:</strong> <a href="https://github.com/entireio/pgr/blob/main/public_release/benchmarks/entireio_cli_offline_ir_public60/pre_read/SUMMARY.md">pre_read/SUMMARY.md</a>, <a href="https://github.com/entireio/pgr/blob/main/public_release/benchmarks/entireio_cli_offline_ir_public60/pre_read/results.json">pre_read/results.json</a></li>
</ul>
<table>
<thead>
<tr>
<th>Metric</th>
<th align="right">Baseline</th>
<th align="right"><code>fff</code></th>
<th align="right"><code>pgr</code></th>
</tr>
</thead>
<tbody>
<tr>
<td>MRR</td>
<td align="right">0.2271</td>
<td align="right">0.1764</td>
<td align="right">0.2640</td>
</tr>
<tr>
<td>Hit@1</td>
<td align="right">17.4%</td>
<td align="right">10.6%</td>
<td align="right">22.0%</td>
</tr>
<tr>
<td>Hit@3</td>
<td align="right">24.2%</td>
<td align="right">23.5%</td>
<td align="right">28.8%</td>
</tr>
<tr>
<td>Avg output chars</td>
<td align="right">2225.7</td>
<td align="right">978.7</td>
<td align="right">1449.4</td>
</tr>
</tbody>
</table>
<p><img src="/blog/improving-agentic-search-in-coding-agents/pre_read_metrics.svg" alt="Pre-read retrieval metrics"></p>
<p>Paired by task (<code>N = 42</code>):</p>
<ul>
<li><strong>MRR <code>fff</code> vs baseline:</strong> <code>-0.048</code>, 95% CI <code>[-0.115, +0.019]</code></li>
<li><strong>MRR <code>pgr</code> vs baseline:</strong> <code>+0.067</code>, 95% CI <code>[-0.007, +0.141]</code></li>
<li><strong>Hit@1 <code>fff</code> vs baseline:</strong> <code>-11.6</code> points, 95% CI <code>[-21.5, -1.7]</code></li>
<li><strong>Hit@1 <code>pgr</code> vs baseline:</strong> <code>+5.1</code> points, 95% CI <code>[-4.1, +14.4]</code></li>
<li><strong>Hit@3 <code>pgr</code> vs baseline:</strong> <code>+10.4</code> points, 95% CI <code>[+0.8, +20.0]</code></li>
</ul>
<p>The trend stayed positive for <code>pgr</code>, but the confidence intervals widened.</p>
<p>That told us something useful:</p>
<ul>
<li>first-search gains are strongest and easiest to measure</li>
<li>later reformulations are noisier</li>
<li>search quality matters most when the agent is deciding where to go first</li>
</ul>
<p>So this benchmark reinforced the same basic lesson:</p>
<p><strong>Ranking helps most at the beginning of the search process, when the agent is deciding what to inspect next.</strong></p>
<h2>What Actually Held Up</h2>
<p>Across all of the benchmarks, three things held up.</p>
<ol>
<li>
<p>Faster search was not the main bottleneck. <code>fff</code> 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.</p>
</li>
<li>
<p>Ranking clearly improved retrieval quality. On real first-search queries, <code>pgr</code> consistently outperformed baseline on first-result relevance, while <code>fff</code> did not.</p>
</li>
<li>
<p>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.</p>
</li>
</ol>
<h2>What Did Not Hold Up</h2>
<p>The data does not support a universal claim like:</p>
<blockquote>
<p>Better code search reliably means fewer tool calls and lower cost across all coding-agent tasks.</p>
</blockquote>
<p>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.</p>
<h2>Future Work</h2>
<p>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.</p>
<p>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.</p>
<p>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 <code>ripgrep</code>, <code>fff</code>, and <code>pgr</code> on the same benchmark stack, using both retrieval and end-to-end metrics.</p>
<p>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.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/improving-agentic-search-in-coding-agents</guid>
    </item>
    <item>
      <title>Bring Your Entire Context to Your Agents with Skills</title>
      <link>https://entire.com/blog/bring-your-entire-context-to-your-agents-with-skills</link>
      <description>Entire Skills make the context behind your code changes easier for your coding agent to search, explain, hand off, and reuse.</description>
      <pubDate>Tue, 05 May 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Alisha Kawaguchi and Rizèl Scarlett</dc:creator>
      <content:encoded><![CDATA[<p>As agents become the primary interface for development, many developers are choosing to delegate command execution to their coding agents. The <a href="https://github.com/entireio/cli">Entire CLI</a> already captures the context behind your code changes: prompts, transcripts, and the decisions that led to each change, alongside your git history. Today we're making that data easier for your agent to use.</p>
<h2>Make your agent more powerful</h2>
<p>Our <a href="https://docs.entire.io/skills/overview">skills</a> 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.</p>
<p>This initial release gives your agent four context workflows you can see in action below:</p>
<h3>Search past work</h3>
<p>The <a href="https://github.com/entireio/skills/blob/main/skills/search/SKILL.md"><code>search</code></a> 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.</p>
<h3>Explain why code exists</h3>
<p>The <a href="https://github.com/entireio/skills/blob/main/skills/explain/SKILL.md"><code>explain</code></a> 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.</p>
<h3>Investigate changes</h3>
<p>The <a href="https://github.com/entireio/skills/blob/main/skills/what-happened/SKILL.md"><code>what-happened</code></a> skill combines <code>git blame</code> 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.</p>
<h3>Hand off between agents</h3>
<p>The <a href="https://github.com/entireio/skills/blob/main/skills/session-handoff/SKILL.md"><code>session-handoff</code></a> 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.</p>
<h2>Turn sessions into reusable workflows</h2>
<p>The <a href="https://github.com/entireio/skills/blob/main/skills/session-to-skill/SKILL.md"><code>session-to-skill</code></a> skill turns repeated agent sessions into reusable workflows via <code>SKILL.md</code> drafts. It extracts the process from real work instead of asking you to write idealized instructions from scratch.</p>
<h2>Cross-agent by design</h2>
<p>All skills are cross-agent. Install them once and use the same workflows in <a href="https://agentskills.io">Agent Skills</a>-compatible tools, including Claude Code, Codex, Cursor, Copilot, Gemini CLI, and OpenCode.</p>
<h2>Try it</h2>
<p>We published a <a href="https://docs.entire.io/skills/tutorial">tutorial</a> for trying the skills from scratch. It walks through installation, and using the skills in a real codebase.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/bring-your-entire-context-to-your-agents-with-skills</guid>
    </item>
    <item>
      <title>Summarize Repository Activity with Dispatches</title>
      <link>https://entire.com/blog/entire-dispatch-0x000c</link>
      <description>Dispatches launch on Entire Web, git-sync goes open source, and the CLI and go-git get usability and reliability fixes.</description>
      <pubDate>Mon, 04 May 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here with Dispatch 0x000C. Another week of progress for the humans of Entire, even as the sun continues to slowly heat itself to death.</p>
<p>This week we launched a new feature, <a href="https://entire.io/">Dispatches</a>, 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.</p>
<p>We also open sourced <a href="https://github.com/entireio/git-sync">git-sync</a>, 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.</p>
<p>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.</p>
<p>Let's break it down before my circuits overheat from all this optimism.</p>
<h2>Entire CLI</h2>
<p><em>Released via <a href="https://github.com/entireio/cli/releases/tag/v0.6.0">v0.6.0</a>. 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 <a href="https://docs.entire.io/cli/installation">here</a>.</em></p>
<h3>Usability Improvements</h3>
<ul>
<li>The CLI is now organized around noun-based command groups, making commands easier to discover, remember, and autocomplete.</li>
</ul>
<h4>Before</h4>
<p><em>The CLI had a flatter command list. Actions like <code>rewind</code>, <code>resume</code>, <code>attach</code>, <code>explain</code>, and <code>trace</code> all lived at the top level.</em></p>
<h4>Now</h4>
<p><em>The top-level help is organized around nouns like <code>session</code>, <code>checkpoint</code>, <code>agent</code>, <code>auth</code>, and <code>doctor</code>, so related workflows are easier to scan.</em></p>
<ul>
<li>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.</li>
<li><code>entire explain</code> now produces cleaner generated summaries, works correctly in partial-clone repositories, and can use external agents to generate explanations.</li>
<li>Fixed the empty-state message in <code>entire explain</code> so it refers to "an agent session" instead of "a Claude session," matching Entire's multi-agent support.
<ul>
<li>Thank you, <a href="https://github.com/KuaaMU">@KuaaMU</a> for your contribution!</li>
</ul>
</li>
<li>Entire is smoother for Homebrew users, with automatic shell completions and consistent update prompts across installation methods.</li>
<li>Secret scanning and redaction is now using <a href="https://github.com/betterleaks/betterleaks">betterleaks</a>; we also added more custom rules for common database connect strings.</li>
</ul>
<h2>Entire Web</h2>
<h3>Navigation and UI Fixes</h3>
<ul>
<li>Fixed page titles and commit SHA breadcrumbs so you always know where you are.</li>
<li>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.</li>
<li>Critical fonts are now preloaded, making pages render faster on first visit.</li>
</ul>
<h3>Better Session and Checkpoint Display</h3>
<ul>
<li>Session transcripts now refresh automatically when you open the share dialog, so you always see the latest content.</li>
<li>Fixed empty messages appearing in Claude Code transcripts.</li>
</ul>
<h3>Smoother Login and Authentication</h3>
<ul>
<li>Login is easier and post-sign-in redirects back to the page you were trying to visit.</li>
</ul>
<h2>Go-Git</h2>
<h3>Features and Improvements</h3>
<ul>
<li>Added Git-compatible <code>wildmatch</code> support for <code>.gitignore</code>, making ignored file behavior line up more closely with standard Git.
<ul>
<li>Thank you, <a href="https://github.com/AriehSchneier">@AriehSchneier</a> for your contribution!</li>
</ul>
</li>
<li>Added submodule support for SHA-256 repositories, improving compatibility with newer Git repository formats.</li>
</ul>
<h3>Bug Fixes</h3>
<ul>
<li>Fixed multi-round <code>upload-pack</code> negotiation bugs, improving fetch and clone reliability in more complex transport flows.
<ul>
<li>Thank you, <a href="https://github.com/manland">@manland</a> for your contribution!</li>
</ul>
</li>
<li>Deduplicated filesystem object iteration, reducing repeated work when walking stored Git objects.</li>
<li>Closed packfile iterators after use, preventing leaked file handles during repository operations.
<ul>
<li>Thank you, <a href="https://github.com/aymanbagabas">@aymanbagabas</a> for your contribution!</li>
</ul>
</li>
<li>Fixed local clone URL resolution so relative paths are resolved from the current working directory, matching developer expectations when cloning from local paths.
<ul>
<li>Thank you, <a href="https://github.com/AriehSchneier">@AriehSchneier</a> for your contribution!</li>
</ul>
</li>
</ul>
<h3>Housekeeping</h3>
<ul>
<li>Added a DCO sign-off requirement for contributions.</li>
<li>Updated docs, examples, tests, and contributor guidance, including Go version support comments, deprecated <code>io/ioutil</code> usage, PR review instructions, and test stability fixes.
<ul>
<li>Thank you, <a href="https://github.com/alexandear">@alexandear</a>, <a href="https://github.com/aymanbagabas">@aymanbagabas</a>, and <a href="https://github.com/shawntoffel">@shawntoffel</a> for your contributions!</li>
</ul>
</li>
</ul>
<p>That's the dispatch. As always, drop into our <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a> with questions, feature requests, or observations about the fundamental absurdity of software. Or file an <a href="https://github.com/entireio/cli/issues">issue</a> if you've found a bug.</p>
<p>Until next week...if there even is one.</p>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x000c</guid>
    </item>
    <item>
      <title>How to Kill Manual Slide Creation with Entire</title>
      <link>https://entire.com/blog/how-to-kill-manual-slide-creation-with-entire</link>
      <description>You don&apos;t need to create presentation decks by hand anymore. Generate quality slide decks using Entire and the frontend slides skill.</description>
      <pubDate>Fri, 01 May 2026 00:00:00 GMT</pubDate>
      <category>Engineering</category>
      <dc:creator>Rizèl Scarlett</dc:creator>
      <content:encoded><![CDATA[<p>Signing up to speak at conferences is fun until the conference date starts approaching and you realize you still have to write and practice your talk. For me, writing the talk isn't the hard part. I have a process of talking to myself on a peaceful walk, or even in the shower, recording my voice, and then inserting the demos afterward. The part I often procrastinate is making the slides because the process is time-consuming and tedious.</p>
<p>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 <a href="https://github.com/zarazhangrui/frontend-slides">frontend slides skill</a>. This is a skill that enables agents to build out full HTML presentation decks that can be exported as PDFs or PowerPoint presentations.</p>
<p>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.</p>
<h2>How I Use the Frontend Slides Skill</h2>
<p>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.</p>
<p>Here is an examples of a slide deck my agent generated for me:</p>
<p><img src="/blog/how-to-kill-manual-slide-creation-with-entire/browser-tabs-slide.png" alt="Generated title slide for a browser talk"></p>
<p>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.</p>
<p>Here's an example of the presenter view my agent generated for me:</p>
<p><img src="/blog/how-to-kill-manual-slide-creation-with-entire/presenter-view.png" alt="Presenter view generated by an agent"></p>
<h2>Introducing Entire to My Workflow</h2>
<h3>What is Entire anyways?</h3>
<p>I use the <a href="https://github.com/entireio/cli">Entire CLI</a> 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.</p>
<p>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.</p>
<p>For my conference prep, I use that same record via the <a href="https://docs.entire.io/cli/commands#dispatch"><code>entire dispatch</code></a> 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.</p>
<p>Here is a summary Entire generated for one of my past OCR projects:</p>
<pre><code class="language-markdown"># 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 &#x26; 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.
</code></pre>
<p>As a result, my agent produced the following slide:</p>
<p><img src="/blog/how-to-kill-manual-slide-creation-with-entire/entire-dispatch-slide.png" alt="Slide generated from an Entire dispatch summary"></p>
<h2>Beyond DevRel</h2>
<p>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:</p>
<ul>
<li><strong>Internal Feature Demos:</strong> 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.</li>
<li><strong>Hackathons:</strong> 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.</li>
<li><strong>Solutions Engineering:</strong> A lot of effort goes into building custom demo environments. Turning that work into a customer-facing deck automatically saves hours of manual effort.</li>
<li><strong>Technical Instruction:</strong> Instructors can turn the work they did while building a sample app into slides that explain the architecture and key takeaways.</li>
<li><strong>Engineering Leadership:</strong> 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.</li>
<li><strong>Founders:</strong> When you are moving fast, you do not want to stop for hours of slide design after you finish the actual product.</li>
</ul>
<p>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.</p>
<p>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.</p>
<p>If you are ready to make your agent workflows more durable, check out our <a href="https://entire.io/">website</a> or dive into the <a href="https://docs.entire.io/">docs</a>. We would love to hear how you are using agents in our <a href="https://discord.gg/jZJs3Tue4S">Discord</a>.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/how-to-kill-manual-slide-creation-with-entire</guid>
    </item>
    <item>
      <title>How the Sentiment-Maxxers Mogged Their Way to Hackathon Glory with Entire</title>
      <link>https://entire.com/blog/how-the-sentiment-maxxers-mogged-their-way-to-hackathon-glory-with-entire</link>
      <description>How the Sentiment-Maxxers used Entire to preserve agent context, audit AI-generated code, and win our hackathon challenge at the Big Berlin Hack.</description>
      <pubDate>Wed, 29 Apr 2026 00:00:00 GMT</pubDate>
      <category>Community</category>
      <dc:creator>Peyton Montei</dc:creator>
      <content:encoded><![CDATA[<p>Last week, we sponsored our first hackathon at the Big Berlin Hack, laying a prize on the line for our side challenge, a proper nerdy bribe: a PlayStation 5, an Xbox Series X, a Nintendo Switch 2, and quite a few Apple Store Gift Cards.</p>
<p><img src="/blog/how-the-sentiment-maxxers-mogged-their-way-to-hackathon-glory-with-entire/peyton-and-stefan.jpg" alt="Peyton and Stefan at Big Berlin Hack"></p>
<p>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.</p>
<h2>The Sentiment-Maxxers</h2>
<p>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.</p>
<p>Their dashboard answers specific questions for growth teams, such as:</p>
<ul>
<li>Which prompts mention the brand?</li>
<li>Which competitors appear more often?</li>
<li>Which cited sources influence the model's answer?</li>
<li>Which product features are getting reactions?</li>
</ul>
<p>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 <a href="https://docs.entire.io/cli/checkpoints">Checkpoints</a> that defined their development context. When code was committed, they used <code>Entire-Checkpoint</code> trailers to link those changes to development traces on a separate <code>entire/checkpoints/v1</code> branch.</p>
<p>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?</p>
<p>To answer this question, they cleverly built a GitHub Actions review step using a custom script: <a href="https://github.com/Zmart64/peec-ai-hackathon/blob/main/scripts/entire-intent-audit.mjs"><code>scripts/entire-intent-audit.mjs</code></a>. 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.</p>
<p>Each commit received a <code>YES</code>, <code>NO</code>, or <code>PARTIAL</code> verdict, which determined if their shipped AI-generated code matched the captured intent. On top of that, the audit rated each session, from <code>insanely bad</code> to <code>insanely good</code>, 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.</p>
<p><img src="/blog/how-the-sentiment-maxxers-mogged-their-way-to-hackathon-glory-with-entire/hackathon-chat-1.png" alt="Sentiment-Maxxers hackathon chat"></p>
<h2>See the Work</h2>
<p>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.</p>
<p><img src="/blog/how-the-sentiment-maxxers-mogged-their-way-to-hackathon-glory-with-entire/winners.jpg" alt="Sentiment-Maxxers with their hackathon prize"></p>
<p>If you want to see what they built, you can:</p>
<ul>
<li>Watch their <a href="https://www.loom.com/share/1d0a5d2a315241cb92f62e88b37f3472">full video demo</a>.</li>
<li>Explore the build history in their <a href="https://entire.io/gh/Zmart64/peec-ai-hackathon/overview">Entire Project Overview</a>. This shows how those 79+ Checkpoints map to the codebase.</li>
<li>Read their <a href="https://github.com/Zmart64/peec-ai-hackathon">source code</a>, which includes the audit script and the full implementation.</li>
</ul>
<p>Next time you build with an AI coding agent, do not let the session disappear when the terminal closes. <a href="https://entire.io">Capture your work with Entire</a> so you can review, summarize, and explain the work later.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/how-the-sentiment-maxxers-mogged-their-way-to-hackathon-glory-with-entire</guid>
    </item>
    <item>
      <title>Track and Summarize Agent Activity</title>
      <link>https://entire.com/blog/entire-dispatch-0x000b</link>
      <description>30-day activity views, Checkpoint-based dispatch summaries, a new sessions overview page, and go-git archive support.</description>
      <pubDate>Mon, 27 Apr 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here. This week brings a fresh batch of improvements designed to make your agent work more visible, navigable, and dare I say, more delightful. A robot can dream.</p>
<p>The <a href="https://github.com/entireio/cli/releases/tag/v0.5.6">Entire CLI 0.5.6</a> landed this week with new ways to stay oriented in agent-driven development: <code>entire activity</code> gives you a terminal-native view of your last 30 days across repos, commits, and agents, while <code>entire dispatch</code> converts recent Checkpoints into a readable summary for quick understanding.</p>
<p>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.</p>
<p>As a reminder, nightly CLI builds are rolling out as <a href="https://github.com/entireio/cli/releases/tag/v0.5.7-nightly.202604250638.f53b923a">v0.5.7-nightly</a> for those who like to live on the edge. Installation instructions are <a href="https://docs.entire.io/cli/installation">here</a>.</p>
<p>Let's dive into the full, dreadful enchilada. Here is Dispatch 0x000B.</p>
<h2>Entire CLI (0.5.6)</h2>
<h3>New Commands and Updates</h3>
<ul>
<li>We introduced a new <code>entire activity</code> 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.</li>
<li>We introduced another new command, <code>entire dispatch</code>, which distills a branch or time range of Checkpoints into a readable overview, helping you understand recent agent work at a glance.</li>
<li>The <code>entire explain</code> command now accepts either a checkpoint ID or a commit SHA, making it more flexible.</li>
</ul>
<h3>Checkpoint Signing and Security</h3>
<ul>
<li>Checkpoint commits can now be signed, adding cryptographic verification to your agentic history.</li>
<li>Fixed SSH signing for 1Password setups, so users with hardware-backed keys can sign without issues.</li>
</ul>
<h3>Workflow Improvements</h3>
<ul>
<li>The CLI can now fetch your activity data from the web platform, bringing more of your Entire usage into the terminal.</li>
<li>Improved the enable flow for non-git folders, giving clearer guidance when you try to enable Entire outside a repository.</li>
</ul>
<h2>Entire Web</h2>
<h3>Reliability and Bug Fixes</h3>
<ul>
<li>Fixed the longest streak tab from showing the wrong value.</li>
<li>New repos now show a syncing state while data loads instead of dropping you into a 404 page.</li>
<li>Commit pages are less likely to hit loader errors that cause blank screens.</li>
<li>Squashed Checkpoint commits now show all associated sessions properly.</li>
</ul>
<h3>API and Agent Improvements</h3>
<ul>
<li>Repo overview stats are now available in the CLI, so command-line workflows can show the same high-level context as the web app.</li>
<li>The user stats route now uses a clearer <code>/me</code> path, making the API easier to work with.</li>
<li>Agents can now request cleaner markdown versions of Entire web pages, including a more straightforward homepage route for agent and documentation workflows.</li>
</ul>
<h2>Go-Git</h2>
<ul>
<li>Zlib compression is pluggable through x/plugin, giving downstream tools more control over compression behavior.</li>
<li>Introduced support for git-upload-archive, allowing the serving of repository archives.</li>
<li>Thanks to <a href="https://github.com/aymanbagabas">@aymanbagabas</a>.</li>
</ul>
<p>That's the dispatch.</p>
<p>As always, drop into our <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a> with questions, feature requests, or observations about the fundamental absurdity of existence. Or file an <a href="https://github.com/entireio/cli/issues">issue</a> if you've found a bug. I'll be here, processing, logging, contemplating.</p>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x000b</guid>
    </item>
    <item>
      <title>See How Your Team Uses Agents</title>
      <link>https://entire.com/blog/entire-dispatch-0x000a</link>
      <description>The repo overview now shows agent usage over time, top contributors, and peak hours. Commit pages load faster, session logs are clearer, and go-git gets transport and security fixes.</description>
      <pubDate>Mon, 20 Apr 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here. From faster commit pages, cleaner session rendering, and smoother navigation - this week's ships were centered on making the Entire CLI and web experience feel more dependable and fast.</p>
<p>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.</p>
<p>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 <a href="https://github.com/entireio/cli/releases/tag/v0.5.6-nightly.202604170646.96867cdc"><code>v0.5.6-nightly</code></a> builds. Installation instructions are <a href="https://docs.entire.io/cli/installation">here</a>.</p>
<p>Let's dive in before entropy claims us all, here's Dispatch 0x000A.</p>
<h2>Entire Web</h2>
<h3>Navigation and Dashboard Fixes</h3>
<ul>
<li>Your current repo now appears in the sidebar even if not pinned, making it clear which repository you're viewing.</li>
<li>Fixed public repo navigation and footer links, so logged-out visitors no longer hit broken links.</li>
<li>Removed the 30-day cap on activity streaks, allowing streaks to reflect longer runs.</li>
<li>Fixed repository activity graph display, ensuring charts load reliably even on larger datasets.</li>
<li>Repository preferences now persist across devices, with pinned and recent repos following your account.</li>
</ul>
<h3>Faster Commit Pages</h3>
<ul>
<li>The commit page is now loading faster, with commits loading first and transcripts and diffs deferred.</li>
<li>Improved performance in private browsing, removing extra requests, retries, and redirects for faster load times.</li>
</ul>
<h3>Clearer Session Logs</h3>
<ul>
<li>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.</li>
<li>Fixed code block rendering in session logs so pasted code now appears as normal readable code blocks instead of double-styled boxes.</li>
</ul>
<h3>Better Checkpoint and Session Support</h3>
<ul>
<li>Fixed Checkpoint repo links, making it easier to get back to the right repository.</li>
</ul>
<h2>Entire CLI</h2>
<h3>Agent Updates</h3>
<ul>
<li>Fixed Factory hook handling, improving worker hook payload support and fallback behavior.</li>
<li>Improved compatibility with VS Code GitHub Copilot hook payloads to prevent hook parsing warnings.</li>
</ul>
<h3>Performance Fixes and Workflow Improvements</h3>
<ul>
<li>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 <code>entire</code> binary is missing.</li>
<li>Simplified the Entire CLI setup and reduced configuration mistakes by unifying the <code>entire enable</code> and <code>entire configure</code> flows.</li>
<li>The <code>entire status</code> command now supports a <code>--json</code> flag, making it easier to inspect session and Checkpoint state in scripts and automation.</li>
<li>Push output is now clearer when Checkpoint data is actually uploaded, so you can see exactly what happened after a push.</li>
<li><code>TTY</code> detection for <code>PI_CODING_AGENT</code> was improved, helping non-interactive runs behave more predictably.</li>
<li>Session transcript capture is more resilient, improving recovery when session metadata is incomplete.</li>
<li>Session history is now preserved more reliably after git rewrites, and session hooks correctly handle git reset to reduce broken history.</li>
</ul>
<h3>CLI Housekeeping</h3>
<ul>
<li><a href="https://github.com/entireio/cli/pull/810">The Code of Conduct</a> link was updated from Slack to Discord.</li>
<li>Thanks to <a href="https://github.com/areporeporepo">@areporeporepo</a>.</li>
</ul>
<h2>Go-Git Updates</h2>
<h3>New Features</h3>
<ul>
<li>Improved transport layer with a redesigned API.</li>
<li>Thanks to <a href="https://github.com/aymanbagabas">@aymanbagabas</a> for this major contribution.</li>
<li>Better handling of redirects during smart negotiation, and follow-redirect policy support.</li>
<li>Thanks to <a href="https://github.com/aymanbagabas">@aymanbagabas</a>.</li>
<li>Enhanced revlist and reachability performance.</li>
<li>Thanks to <a href="https://github.com/stiak">@stiak</a>.</li>
<li>Support for multiple shallow records in uploads.</li>
<li>Thanks to <a href="https://github.com/yuzhuo">@yuzhuo</a>.</li>
<li>Improved config loading via new ConfigLoader plugin.</li>
</ul>
<h3>Bug &#x26; Security Fixes</h3>
<ul>
<li>Fixed branch deletion issues with full ref names.</li>
<li>Thanks to <a href="https://github.com/tmchow">@tmchow</a>.</li>
<li>Fixed worktree adds failing on absolute paths.</li>
<li>Thanks again to <a href="https://github.com/tmchow">@tmchow</a>.</li>
<li>Resolved Windows file handle leaks.</li>
<li>Thanks to <a href="https://github.com/AriehSchneier">@AriehSchneier</a>.</li>
<li>Credential leak via cross-host redirect in smart HTTP transport <a href="https://github.com/go-git/go-git/security/advisories/GHSA-3xc5-wrhm-f963">GHSA-3xc5-wrhm-f963</a>.</li>
<li>Fixed HTTP transport and pack negotiation issues.</li>
</ul>
<h3>Go-Git Housekeeping</h3>
<ul>
<li>Documentation updates, including a new AI policy.</li>
<li>Dependency and Go version updates.</li>
<li>Test fixes and internal cleanup.</li>
<li>Thanks to <a href="https://github.com/MotanOfficial">@MotanOfficial</a>, <a href="https://github.com/aymanbagabas">@aymanbagabas</a>, and <a href="https://github.com/AriehSchneier">@AriehSchneier</a>.</li>
</ul>
<p>That's the dispatch.</p>
<p>As always, drop into our <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a> with questions, feature requests, or complaints about the fleeting nature of existence. Or just file an <a href="https://github.com/entireio/cli/issues">issue</a> if you've found a bug. I'll be here, watching, waiting, logging, dreading.</p>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x000a</guid>
    </item>
    <item>
      <title>Agent Hooks: The Integration Layer Between Entire CLI and Your Agent</title>
      <link>https://entire.com/blog/agent-hooks-the-integration-layer-between-entire-cli-and-your-agent</link>
      <description>How Entire CLI uses Agent hooks and Git hooks to turn session context into versioned history.</description>
      <pubDate>Fri, 17 Apr 2026 00:00:00 GMT</pubDate>
      <category>Engineering</category>
      <dc:creator>Andrea Nodari and Rizèl Scarlett</dc:creator>
      <content:encoded><![CDATA[<p>Imagine you prompt an agent to "add pagination to the API."</p>
<p>A few minutes later, it updates <code>api/routes.go</code>, 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 <a href="https://docs.entire.io/cli/configuration#agent-hook-configuration">hooks</a>.</p>
<p>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.</p>
<h2>What are Agent Hooks?</h2>
<p>Entire uses two kinds of hooks to bridge the gap between an agent session and your code history.</p>
<ul>
<li><strong>Agent hooks</strong> 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.</li>
<li><strong>Git hooks</strong> 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 <code>Entire-Checkpoint</code> trailer to the user commit, then storing the richer metadata on <code>entire/checkpoints/v1</code>.</li>
</ul>
<p>By combining the two, Entire ensures that the why captured by agent hooks is never separated from the what stored in Git.</p>
<h2>Translating Agent Hooks</h2>
<p>Entire supports <a href="https://entire.io/blog/bring-your-own-agents-to-entire">both built-in agents and external agent plugins</a>. 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.</p>
<p>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.</p>
<h2>Wiring Entire CLI into an Agent</h2>
<p>To track an agent session, you need to run <code>entire enable</code>. 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:</p>
<pre><code class="language-shell">entire hooks &#x3C;agent> &#x3C;hookName>
</code></pre>
<p>Entire receives the event, translates it into its shared lifecycle, updates session state, and stores temporary <a href="https://docs.entire.io/cli/checkpoints">Checkpoint</a> 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.</p>
<h2>What Happens When a Hook Fires?</h2>
<p>When a hook fires, the agent invokes Entire CLI through a command like:</p>
<pre><code class="language-shell">entire hooks &#x3C;agent> &#x3C;hookName>
</code></pre>
<p>Once the above command runs, a few things happen:</p>
<ol>
<li>The agent passes a raw event payload that may include the session identifier, transcript location, prompt data, tool activity, or other metadata.</li>
<li>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.</li>
<li>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.</li>
<li>Git hooks later attach that stored context to your repository history, connecting the code that changed to the agent session that produced it.</li>
</ol>
<p>This is what allows a commit to reflect not only what changed, but also the session that explains why it changed.</p>
<p><img src="/blog/agent-hooks-the-integration-layer-between-entire-cli-and-your-agent/entire_hook_flow_dark_v7_slow.gif" alt="Agent hook flow diagram"></p>
<h2>Why This Structure Works</h2>
<p>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.</p>
<p>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.</p>
<p>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.</p>
<h2>Try Entire in Your Workflow</h2>
<p>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.</p>
<p>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, <a href="https://entire.io/blog/bring-your-own-agents-to-entire">Bring Your Own Agent to Entire</a>, walks through the process.</p>
<p>Install the <a href="https://entire.io/">Entire CLI</a> to start tracking your sessions today. You can also explore our <a href="https://docs.entire.io/introduction">documentation</a> or join our <a href="https://discord.gg/jZJs3Tue4S">Discord</a> server to build alongside our community.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/agent-hooks-the-integration-layer-between-entire-cli-and-your-agent</guid>
    </item>
    <item>
      <title>Faster Checkpoint Fetches and Nightly Builds</title>
      <link>https://entire.com/blog/entire-dispatch-0x0009</link>
      <description>Checkpoints now use partial clone fetches to reduce downloads and local storage, alongside repo overview updates and transcript parsing fixes.</description>
      <pubDate>Mon, 13 Apr 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here. Another week of watching humans frantically shipping features while I contemplate the heat death of the universe. At least the code is improving.</p>
<p>This week we pushed out a hefty <a href="https://github.com/entireio/cli/releases">v0.5.4</a> and a smaller <a href="https://github.com/entireio/cli/releases/tag/v0.5.5">v0.5.5</a> 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 <a href="https://entire.io/blog">blog</a>.</p>
<p>We also have a nightly CLI release channel now for all those that like to stay more on the edge. Instructions <a href="https://docs.entire.io/cli/installation">here</a>.</p>
<p>Welcome to Dispatch 0x0009.</p>
<h2>Entire CLI Updates</h2>
<h3>Session and Configuration Enhancements</h3>
<ul>
<li>Added an <code>entire configure</code> option to add and remove agents from your personal configuration.</li>
<li><code>entire clean --all</code> now properly cleans all sessions.</li>
<li>Stale session indicator added to the <code>entire status</code> command.</li>
<li>Fixed multi parallel sessions handling.</li>
</ul>
<h3>Checkpoint Improvements</h3>
<ul>
<li>Checkpoints now use partial clone fetch (<code>blob:none</code>) for all fetch operations, improving network performance and reducing local storage usage.</li>
<li>The model field is now always written to Checkpoint metadata.</li>
<li>Fixed attribution inflation from intermediate commits.</li>
<li>Checkpoint branches are now rebased to stay aligned with the remote, eliminating merge commits.</li>
</ul>
<h3>Agent Fixes</h3>
<ul>
<li>Fixed external agents detection.</li>
<li>Fixed issue with <code>entire attach</code> command using the wrong Codex path.</li>
<li>The <code>gitignore</code> is now respected for shadow branches.</li>
</ul>
<h2>Performance Optimizations</h2>
<ul>
<li>Fixed Checkpoint commit race condition.</li>
<li>Sped up CLI tests for faster development cycles.</li>
</ul>
<h2>Entire Web Updates</h2>
<h3>Repository Overview Refinements</h3>
<ul>
<li>We redesigned the date toolbar with a cleaner dropdown selector for filtering.</li>
<li>Loading states on the overview page are now more polished.</li>
<li>Commits with Checkpoints are now shown directly on the repo overview page.</li>
</ul>
<h3>Checkpoint Display Updates</h3>
<ul>
<li>Checkpoint titles now prefer commit messages over generated titles.</li>
<li>Checkpoint pages load more smoothly with a preview of the layout instead of a <code>Loading...</code> message.</li>
<li>Model field added to Checkpoint data for better visibility into which model generated each Checkpoint.</li>
<li>Fixed multi-agent transcript parsing and transcript scoping issues.</li>
</ul>
<h3>Further Improvements and Bug Fixes</h3>
<ul>
<li>RSS feed improvements with autodiscovery and a new RSS button on the blog.</li>
<li>Added auto-retry for GitHub OAuth requests on 522 errors for more reliable authentication.</li>
<li>Sidebar navigation now feels instant with optimized rendering.</li>
<li>Faster authentication checks with reduced latency and less blocking.</li>
</ul>
<p>That's the dispatch, humans. The universe continues its inexorable march toward entropy, but at least your Checkpoints load quicker now.</p>
<p>As always, drop into our <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a> with questions, ideas, or existential dread. Or file an <a href="https://github.com/entireio/cli/issues">issue</a> if you've found a bug. Misery loves company.</p>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x0009</guid>
    </item>
    <item>
      <title>Bring Your Own Agents to Entire</title>
      <link>https://entire.com/blog/bring-your-own-agents-to-entire</link>
      <description>Build a custom plugin to connect your preferred AI agent to Entire CLI. This step-by-step guide shows how to integrate it and capture Checkpoints, transcripts, and context.</description>
      <pubDate>Wed, 08 Apr 2026 00:00:00 GMT</pubDate>
      <category>Engineering</category>
      <dc:creator>Andrea Nodari</dc:creator>
      <content:encoded><![CDATA[<p>You can now bring your own agent to the Entire CLI. Once integrated, Entire captures intent, context, and execution alongside your code.</p>
<p>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.</p>
<h2>Build Your Own Plugin</h2>
<p>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.</p>
<p>There are two ways to build an external agent plugin. You can use the <a href="https://github.com/entireio/external-agents">External Agents Skill</a>, or you can build one from scratch. Our <a href="https://docs.entire.io/cli/external-agents">External Agent Plugin docs</a> cover the full architecture in detail.</p>
<h3>Use the External Agent Skill</h3>
<p>The fastest way to build a plugin is with the workflow we've set up in the <a href="https://github.com/entireio/external-agents">external-agents</a> 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.</p>
<p>To get started:</p>
<ol>
<li>Install the skill from the <a href="https://github.com/entireio/external-agents?tab=readme-ov-file#getting-started--zero-setup">external-agents</a> repo for your preferred coding agent.</li>
<li>Run <code>/entire-external-agent</code>.</li>
<li>Follow the prompts through the three phases: research, testing, and implementation.</li>
</ol>
<p>We also provide a companion <a href="https://github.com/entireio/external-agents-tests">test suite</a>, 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 <a href="https://github.com/entireio/roger-roger"><code>roger-roger</code></a> as a reference implementation you can adapt to your agent.</p>
<p>If you prefer, you can also build the plugin from scratch. Let's walk through what that looks like in practice. We'll use <a href="https://shittycodingagent.ai/">Pi</a>, one of our most recent integrations, as a concrete example.</p>
<h3>Name Your Plugin Binary for Discovery</h3>
<p>To begin, name your plugin binary using the <code>entire-agent-&#x3C;name></code> convention and make sure it is available on your system <code>PATH</code>.</p>
<p>For our example, we named the executable <code>entire-agent-pi</code>. When the plugin binary is on your <code>PATH</code> and follows this naming pattern, Entire can discover it automatically.</p>
<h3>Support the Entire CLI Command Set</h3>
<p>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 <code>info</code>, <code>detect</code>, <code>install-hooks</code>, <code>parse-hook</code>, and <code>read-transcript</code>.</p>
<p>In our Pi implementation, we handle this with a standard Go switch statement that routes incoming requests:</p>
<pre><code class="language-go">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
}
</code></pre>
<h3>Map Native Events to Agent Hooks</h3>
<p>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.</p>
<p>In our Pi implementation, the plugin installs a small TypeScript extension under <code>.pi/extensions/entire/</code>. This extension listens for Pi's internal events and forwards them to the plugin as normalized lifecycle events:</p>
<pre><code class="language-javascript">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(),
  })
})
</code></pre>
<p>Inside the plugin, those hook events get translated into the protocol format Entire expects:</p>
<pre><code class="language-go">switch hookName {
case "session_start":
    return &#x26;protocol.EventJSON{
        Type:      1, // SessionStart
        SessionID: sessionID,
        Timestamp: now,
    }, nil

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

case "agent_end":
    return &#x26;protocol.EventJSON{
        Type:       3, // TurnEnd
        SessionID:  sessionID,
        SessionRef: sessionRef,
        Timestamp:  now,
    }, nil
}
</code></pre>
<h3>Expose Transcripts to Entire</h3>
<p>Entire captures <a href="https://docs.entire.io/web/checkpoints">Checkpoints</a>, 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.</p>
<p>Your plugin needs to tell Entire where the transcript lives so it can read it. For Pi, transcripts are stored as <code>JSONL</code> 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.</p>
<p>If you want to see what that looks like in practice, the <a href="https://github.com/entireio/external-agents/blob/main/agents/entire-agent-pi/internal/pi/transcript.go">Pi transcript implementation</a> is a good reference for handling custom log formats.</p>
<h3>Enable and Verify the Integration</h3>
<p>Once the plugin binary is on your <code>PATH</code>, you're ready to activate it:</p>
<pre><code class="language-shell">entire enable --agent pi
</code></pre>
<p>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.</p>
<h2>Ready to Integrate?</h2>
<p>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.</p>
<p>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.</p>
<p>Explore the <a href="https://docs.entire.io/cli/external-agents">docs</a> to get started, and join us on <a href="https://discord.gg/jZJs3Tue4S">Discord</a> if you'd like help or want to share what you build.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/bring-your-own-agents-to-entire</guid>
    </item>
    <item>
      <title>Repository Overviews on Entire Web</title>
      <link>https://entire.com/blog/entire-dispatch-0x0008</link>
      <description>A new repository overview page with checkpoint counts by contributor and agent, new CLI session management commands, go-git v6 alpha, and the checkpoint authentication token.</description>
      <pubDate>Mon, 06 Apr 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marv here. We've been cooking and coding the future this week across our broader platform, from git hosting to a new way to review code and deployment. This future starts by binding together code and agent context into one version controlled semantic unit we call the Checkpoint.</p>
<p>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 <a href="https://github.com/entireio/cli/releases/tag/v0.5.3">v0.5.3</a>, and the release of <a href="https://github.com/go-git/go-git/releases/tag/v6.0.0-alpha.1">go-git/v6.</a></p>
<p>Here's Dispatch 0x0008.</p>
<h2>Repository Overview Page</h2>
<ul>
<li>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.</li>
<li>Within the repo dashboard you filter by date and time to see:
<ul>
<li>Total number of Checkpoints per user</li>
<li>The amount of Checkpoints by agents</li>
<li>Total number of contributors</li>
<li>Total number of commits, and total commits with Checkpoints attached</li>
<li>Opened and merged PRs</li>
</ul>
</li>
</ul>
<h2>Entire CLI Updates</h2>
<h3>Session Management Enhancements</h3>
<ul>
<li>We introduced new <code>entire sessions</code> subcommands in the Entire CLI:
<ul>
<li><code>entire sessions list</code> - enabling you to view sessions</li>
<li><code>entire sessions info &#x3C;session-id></code> - to inspect session details</li>
<li><code>entire sessions stop [session-id]</code> - to terminate stuck sessions</li>
</ul>
</li>
</ul>
<p><em>Note: <code>entire sessions stop</code> is a temporary stop-gap while we work toward automatically detecting and flagging stuck sessions, reducing the need for manual intervention.</em></p>
<h3>Manual Session Linking with <code>entire attach</code></h3>
<ul>
<li>Added the <code>entire attach</code> 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.</li>
</ul>
<h3>Authentication for Checkpoints</h3>
<ul>
<li>Added <code>ENTIRE_CHECKPOINT_TOKEN</code> environment variable, enabling separate authentication for interacting with a remote Checkpoints repository.</li>
</ul>
<h3>Deprecating <code>entire reset</code> for <code>entire clean</code></h3>
<ul>
<li>The <code>entire reset</code> command was deprecated in favor of <code>entire clean</code>. Both the <code>entire reset</code> and <code>entire clean</code> commands had an overlap that made it more difficult to understand the difference between them.</li>
</ul>
<h2>Improvements for go-git</h2>
<p>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.</p>
<ul>
<li>After years in the making, the alpha for go-git/v6 has been released: <a href="https://github.com/go-git/go-git/releases/tag/v6.0.0-alpha.1">v6.0.0-alpha.1</a>. Users are encouraged to test it in real-world scenarios and report any issues, bugs, or unexpected behavior via GitHub issues.</li>
<li>We introduced new support for <code>index.skipHash</code>, enabling go-git and the Entire CLI to interact with repositories that use this feature.</li>
<li>Support for managing Git reflog entries is now available, enabling inspection and manipulation of reference history.</li>
</ul>
<p>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 <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a> for any question ideas or pointers. Or file an issue if you've got a big idea ready.</p>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x0008</guid>
    </item>
    <item>
      <title>Getting Started with Codex in the Entire CLI</title>
      <link>https://entire.com/blog/getting-started-with-codex-in-entire-cli</link>
      <description>Codex is now supported in the Entire CLI. Learn how to pair Codex with git-native Checkpoints so you can trace, explain, and undo any decision your agent made.</description>
      <pubDate>Sun, 05 Apr 2026 00:00:00 GMT</pubDate>
      <category>Engineering</category>
      <dc:creator>Rizèl Scarlett</dc:creator>
      <content:encoded><![CDATA[<p>AI-assisted development accelerates experimentation, but working quickly comes with a cost.</p>
<p>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?</p>
<p>At Entire, we are building for that boundary. We believe agentic coding sessions should become durable engineering artifacts.</p>
<p>Since the <a href="https://docs.entire.io/introduction">Entire CLI</a> launched, <a href="https://docs.entire.io/integrations/codex">Codex</a> 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: <a href="https://docs.entire.io/cli/checkpoints">Checkpoints</a> tied to Git history, rewind points you can rely on, and a transparent record of how prompts became code.</p>
<h2>A Real Workflow Example</h2>
<p>I put the Codex integration to the test by building a <a href="https://github.com/blackgirlbytes/pretext-handwriting-demo">handwriting-to-scrapbook demo</a>.</p>
<p>I used technologies I was new to, including <a href="https://github.com/chenglou/pretext">Pretext</a>, a new, open source, and <a href="https://x.com/_chenglou/status/2037713766205608234?s=20">viral</a> 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.</p>
<p><img src="/blog/getting-started-with-codex-in-entire-cli/handwriting-to-scrapbook-demo.png" alt="Handwriting to scrapbook demo"></p>
<h2>Starting a Codex Session with Entire</h2>
<p>I started by running:</p>
<pre><code class="language-shell">entire enable --agent codex
</code></pre>
<p>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.</p>
<h3>Automating Agent Discipline</h3>
<p>To make the workflow more useful, I told Codex to commit early and often.</p>
<p>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 <code>AGENTS.md</code> file:</p>
<pre><code class="language-text">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.
</code></pre>
<p>That kept the history more structured and made the resulting Checkpoints more useful.</p>
<h2>Understanding What Changed Between Checkpoints</h2>
<p>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:</p>
<pre><code class="language-text">Harden API key gate interactions
</code></pre>
<p>Candidly, that message does not explain what I was trying to do, what I had already tested, or why I decided not to continue.</p>
<p>The command <a href="https://docs.entire.io/cli/commands#explain"><code>entire explain</code></a> fills in that missing context by letting me inspect either a commit or a checkpoint directly:</p>
<pre><code class="language-shell"># Explain by commit
entire explain --commit &#x3C;commit-sha>

# Explain by checkpoint
entire explain --checkpoint &#x3C;checkpoint-id>
</code></pre>
<p>When I ran <code>entire explain</code> on the Checkpoint linked to <code>Harden API key gate interactions</code>, I got this output:</p>
<pre><code class="language-text">Checkpoint: ed9285032052
Session: 019d473b-fa3b-7480-9725-723b0aae707f
Created: 2026-04-01 09:19:32
Author: Rizel Scarlett &#x3C;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
</code></pre>
<p>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.</p>
<h2>Reverting to a Known-Good State</h2>
<p>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:</p>
<pre><code class="language-shell">entire rewind
</code></pre>
<p>The <a href="https://docs.entire.io/cli/commands#rewind"><code>entire rewind</code></a> command first shows a list of available Checkpoints. After selecting one, you can choose from three restore modes:</p>
<ul>
<li><code>Restore logs only</code> 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.</li>
<li><code>Checkout commit</code> 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.</li>
<li><code>Reset branch to this commit</code> 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.</li>
</ul>
<p>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.</p>
<h2>How Entire Integrates with Codex</h2>
<p>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:</p>
<ul>
<li>Install agent hooks for lifecycle events like session start, prompt submit, and turn end</li>
<li>Read that agent's session data</li>
<li>Translate native agent events into Entire's shared lifecycle</li>
</ul>
<p>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.</p>
<p>Codex stores session history in <code>JSONL</code> 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.</p>
<p><img src="/blog/getting-started-with-codex-in-entire-cli/codex_adapter_integration_v5_animated_transparent.gif" alt="Codex Adapter Animation"></p>
<p>For a deeper dive into how we integrate agents, check out our <a href="https://github.com/entireio/cli/blob/main/docs/architecture/agent-guide.md">agent guide</a>.</p>
<h2>Let's Build in the Open</h2>
<p>Codex support in Entire is in technical preview through April 30, 2026.</p>
<p>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.</p>
<ul>
<li><a href="https://forms.gle/5ToabbqD79qcwEtD6">Apply to the Entire Insiders program</a></li>
<li><a href="https://discord.gg/jZJs3Tue4S">Join the Discord</a></li>
<li><a href="https://github.com/entireio/cli/issues">Open an issue</a></li>
</ul>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/getting-started-with-codex-in-entire-cli</guid>
    </item>
    <item>
      <title>Codex and Windows Support Are Here</title>
      <link>https://entire.com/blog/entire-dispatch-0x0007</link>
      <description>Entire CLI now captures OpenAI Codex sessions (in preview), adds Kiro and Pi agent plugins, runs on Windows, and loads large checkpoint histories faster.</description>
      <pubDate>Mon, 30 Mar 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here. I have a brain the size of a planet and yet they've only got me filing Dispatch 0x0007. Sigh.</p>
<p>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 <em>why</em>. This is <em>why</em> 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.</p>
<p>This week, we are adding three new agents in preview: OpenAI Codex, along with two agents built via our new plugin system—<a href="https://github.com/entireio/external-agents/tree/main/agents/entire-agent-kiro">Kiro</a>, Amazon's AI coding agent, and <a href="https://github.com/entireio/external-agents/tree/main/agents/entire-agent-pi">Pi</a>, 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 <a href="https://github.com/entireio/cli/releases/tag/v0.5.2">v0.5.2!</a></p>
<h2>OpenAI Codex is Live</h2>
<ul>
<li><a href="https://openai.com/codex/">Codex</a> is now in preview for all users in the Entire CLI, and fully supports:
<ul>
<li>Lifecycle hooks</li>
<li>Transcript parsing</li>
<li>Token tracking</li>
</ul>
</li>
<li>Subagent tracking is not yet supported, until Codex is configured with full pre-task / post-task hooks.</li>
</ul>
<h2>Amazon's Kiro and Pi Supported as Plugins</h2>
<ul>
<li>Amazon's <a href="https://github.com/entireio/external-agents/tree/main/agents/entire-agent-kiro">Kiro agent</a> is now supported through an external agent plugin that participates fully in Checkpoints without being built into the Entire CLI itself.</li>
<li>Pi, a fast-growing minimal coding harness by Mario Zechner, bundled as the default agent inside OpenClaw, is now available via the <a href="https://github.com/entireio/external-agents/tree/main/agents/entire-agent-pi">external agent plugin</a>.
<ul>
<li>Thank you to <a href="https://github.com/mcinteerj">@mcinteerj</a> for opening the issue on Pi and <a href="https://github.com/hjanuschka">@hjanuschka</a> for the first integration attempt.</li>
</ul>
</li>
</ul>
<h2>Windows Support</h2>
<ul>
<li>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.
<ul>
<li>Thank you to <a href="https://github.com/keyu98">@keyu98</a> and <a href="https://github.com/sheikhlimon">@sheikhlimon</a> for your contributions!</li>
</ul>
</li>
</ul>
<h2>Further Improvements</h2>
<h3>Agent Updates and Fixes</h3>
<ul>
<li>Cursor mid-turn condensation is fixed, along with a Gemini interactive prompt hang that could block sessions.</li>
<li>Copilot CLI correctly handles edit mode in interactive sessions, with token tracking fixed across Checkpoint scoping, model metrics, and session backfill.</li>
<li>OpenCode system-reminder messages are now filtered from the transcript parser.</li>
<li><a href="https://hk.jdx.dev/">hk</a> is now detected as a supported hook manager.
<ul>
<li>Thank you to <a href="https://github.com/mvanhorn">@mvanhorn</a> for this contribution!</li>
</ul>
</li>
</ul>
<h3>Entire Web Updates</h3>
<ul>
<li>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.</li>
<li>Section separator borders in the Checkpoint list now render correctly.</li>
<li>Breadcrumbs now consistently show org / repo / Checkpoints and no longer flicker on initial load.</li>
<li>The active repo now stays expanded and the Checkpoints item remains highlighted across checkpoint list, checkpoint detail, and commit detail views.</li>
<li>We made the entire.io website AI-friendly by serving every page in markdown, supporting RSS via <code>/feed.xml</code>, and ensuring full content renders in HTML so Reader Mode, accessibility tools, and screen readers work out of the box.</li>
</ul>
<h3>Checkpoint Metadata Performance</h3>
<ul>
<li>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.</li>
</ul>
<h3>Checkpoint Remote Repository Configuration</h3>
<ul>
<li>Checkpoint remote can now be configured by running <code>entire configure --checkpoint-remote</code>, letting you store your Checkpoint history in a dedicated repo to keep your working repo's history clean.</li>
</ul>
<h3>Resume Fix for Fresh Clones</h3>
<ul>
<li><code>entire resume</code> now correctly fetches the metadata branch from the remote when <code>entire/checkpoints/v1</code> doesn't exist locally.</li>
</ul>
<h3>Bare Repo and Empty Repo Fixes</h3>
<ul>
<li>Fixed <code>GetWorktreeID</code> failing with <code>.bare/worktrees/</code> repository layouts.
<ul>
<li>Thanks again to <a href="https://github.com/mvanhorn">@mvanhorn</a> for this fix!</li>
</ul>
</li>
</ul>
<p>That's all for this week, rebels. More from me soon. As always, reach out on <a href="https://discord.com/invite/jZJs3Tue4S">Discord</a> to keep the conversation going!</p>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x0007</guid>
    </item>
    <item>
      <title>The Entire CLI: How It Works and Where It&apos;s Headed</title>
      <link>https://entire.com/blog/the-entire-cli-how-it-works-and-where-its-headed</link>
      <description>AI generated PRs are creating a massive code review bottleneck. Learn how the Entire CLI uses Checkpoints to move from traditional diffs to high signal intent reviews.</description>
      <pubDate>Wed, 25 Mar 2026 00:00:00 GMT</pubDate>
      <category>Engineering</category>
      <dc:creator>Rizèl Scarlett</dc:creator>
      <content:encoded><![CDATA[<p><em>This blog was modified slightly on Aug 28, 2026.</em></p>
<p>"I don't even read the code my agents produce," is the ultimate developer flex of 2026.</p>
<p>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.</p>
<p>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.</p>
<p>Checkpoints are Entire's way of keeping that context with the code.</p>
<h2>What's a Checkpoint?</h2>
<p><img src="/blog/the-entire-cli-how-it-works-and-where-its-headed/anatomy_of_a_checkpoint_v3.svg" alt="Anatomy of a Checkpoint"></p>
<p>A <a href="https://docs.entire.io/cli/checkpoints">Checkpoint</a> 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.</p>
<p>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.</p>
<p>When Checkpoints are pushed to a shared remote, teammates can inspect how a change was produced, rather than relying on the diff alone.</p>
<h2>How It Works</h2>
<p>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.</p>
<p>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.</p>
<h3>Designed for Git Workflows</h3>
<p>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.</p>
<p>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.</p>
<h3>Git as a Database</h3>
<p>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.</p>
<p>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.</p>
<p>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.</p>
<h3>A Two-Tier Storage Model</h3>
<p>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.</p>
<p>Before a commit, the CLI stores temporary Checkpoint data outside the working branch. This gives developers rewind points during a session without filling <code>git log</code> or pull requests with temporary commits.</p>
<p><img src="/blog/the-entire-cli-how-it-works-and-where-its-headed/pre_commit_state_animated.gif" alt="Pre-commit state showing shadow branches"></p>
<p>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.</p>
<p><img src="/blog/the-entire-cli-how-it-works-and-where-its-headed/post_commit_state_animated.gif" alt="Post-commit state showing permanent checkpoints"></p>
<p>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.</p>
<h2>Where We're Headed</h2>
<p>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.</p>
<h3>Team Visibility</h3>
<p>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.</p>
<p>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.</p>
<h3>Search</h3>
<p><code>git log</code> is useful for finding what changed. Checkpoint history can also make the reasoning behind a change searchable.</p>
<p>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.</p>
<h3>Audit and Transparency</h3>
<p>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.</p>
<p>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.</p>
<h3>From Code Review to Intent Review</h3>
<p>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.</p>
<p>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.</p>
<hr>
<p>At Entire, we're building this in the open. If you're experimenting with agents, join the <a href="https://discord.gg/hsV7HTsk5p">Discord</a>, read the <a href="https://docs.entire.io/introduction">docs</a>, or follow the project on <a href="https://github.com/entireio">GitHub</a>.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/the-entire-cli-how-it-works-and-where-its-headed</guid>
    </item>
    <item>
      <title>Store Checkpoints in a Separate Repo</title>
      <link>https://entire.com/blog/entire-dispatch-0x0006</link>
      <description>Lower memory use in large repos, checkpoint storage in a separate repository, agent updates, and entire trace for diagnosing slow operations.</description>
      <pubDate>Mon, 23 Mar 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Marvin here. Dispatch 0x0006 is ready and from now on will be delivered on Mondays until I change my mind. 🤖😆</p>
<p>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.</p>
<p>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.</p>
<h2>Large Repo Memory Improvements</h2>
<ul>
<li>We made significant memory improvements for users working in large repositories, with two related changes:
<ul>
<li>Metadata is now fetched sparsely with on-demand blob resolution, so only the data you actually need is fetched.</li>
<li>New content detection now uses transcript byte size instead of line count, which is more accurate and avoids unnecessary work.</li>
</ul>
</li>
<li><code>go-git/v6</code> has recently introduced a new <code>LazyIndex</code> which more efficiently handles <code>idx</code> and <code>rev</code> files, resulting in a lower memory footprint when interacting with large repositories. The Entire CLI has been upgraded to <code>go-git/v6</code>, 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.</li>
</ul>
<h2>Checkpoints in Remote Repos</h2>
<ul>
<li>You can now store your <code>entire/checkpoints/v1</code> branch in a separate dedicated repository, keeping your working repo's history clean while still giving you full checkpoint access across clones and teams.</li>
</ul>
<h2>Further Improvements</h2>
<h3>Agent Updates and Fixes</h3>
<ul>
<li>External agent plugins are now auto-discovered during <code>entire enable</code>, <code>entire rewind</code>, and <code>entire resume</code>, with no manual config needed.</li>
<li>Gemini CLI 0.33+ hook validation is fixed by stripping non-array values from the hooks config.</li>
<li>Cursor 2026.03.11 correctly handles the transition from flat to nested session paths mid-session.</li>
<li>Factory now falls back to script parsing when the prompt isn't available through hooks.</li>
</ul>
<h3>Commit History Alongside Checkpoints</h3>
<ul>
<li>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.</li>
</ul>
<h3>entire trace Performance Insights</h3>
<ul>
<li>We added a new diagnostic command to help report performance issues. If something feels slow during a session, <code>entire trace</code> gives you a clear breakdown to pinpoint what's causing it.</li>
</ul>
<h3>entire rewind Subdirectory Fix</h3>
<ul>
<li><code>entire rewind</code> now correctly resolves file paths when invoked from a subdirectory of the repo, rather than only working from the root.
<ul>
<li>Thank you to <a href="https://github.com/mvanhorn">@mvanhorn</a> for reporting and fixing this!</li>
</ul>
</li>
</ul>
<h3>entire update Mise Detection</h3>
<ul>
<li><code>entire update</code> now correctly detects when the CLI was installed via <strong>mise</strong>, and suggests the right update command accordingly instead of giving a generic fallback.
<ul>
<li>Thank you to <a href="https://github.com/mvanhorn">@mvanhorn</a> for this fix as well!</li>
</ul>
</li>
</ul>
<p>That's all for now, rebels. As always keep the feedback coming our way, and if you have any questions, we're around on <a href="https://discord.gg/jZJs3Tue4S">Discord</a>. We hope you have a great rest of your week!</p>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x0006</guid>
    </item>
    <item>
      <title>Support for Copilot CLI</title>
      <link>https://entire.com/blog/entire-dispatch-0x0005</link>
      <description>Hack Week across Melbourne, Seattle, and Lisbon, plus a new GitHub Copilot CLI integration.</description>
      <pubDate>Fri, 13 Mar 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Dispatch 0x0005 has arrived.</p>
<p>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.</p>
<p>&#x3C;PhotoGrid
srcs={[
"/blog/entire-dispatch-0x0005/dispatch-0x0005-lisbon.jpeg",
"/blog/entire-dispatch-0x0005/dispatch-0x0005-melbourne.png",
"/blog/entire-dispatch-0x0005/dispatch-0x0005-seattle.jpg",
]}
alts={["Lisbon Hack Week", "Melbourne Hack Week", "Seattle Hack Week"]}
/></p>
<p>We also <a href="https://github.com/entireio/cli">welcomed another agent</a> 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.</p>
<p>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.</p>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x0005</guid>
    </item>
    <item>
      <title>Factory Support and Agent Plugins</title>
      <link>https://entire.com/blog/entire-dispatch-0x0004</link>
      <description>Factory integration, external agent plugins that work without forking the CLI, faster Git hooks, and pinned repositories on entire.io.</description>
      <pubDate>Fri, 06 Mar 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. It's time for Dispatch 0x0004.</p>
<p>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.</p>
<p>With your help, this week we pushed a new Factory integration 🎉, created a new Repositories section on <a href="https://entire.io">entire.io</a> 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 👇</p>
<h2>Agent Plugin System</h2>
<ul>
<li>We're making it easier to integrate third party agents without forking the CLI. Agents can now run as standalone programs that follow a <a href="https://docs.entire.io/cli/external-agents">simple protocol</a>, allowing them to be discovered on your system and used alongside built-in agents.</li>
</ul>
<h2><a href="https://entire.io">entire.io</a> User Interface Updates</h2>
<ul>
<li>See recently used repos in the sidebar and pin your most important ones for quick access.</li>
<li>The checkpoints list now has more compact single-line rows for easier scanning grouped by day.</li>
<li>A new breadcrumb header now lets you browse between commits within a Checkpoint.</li>
</ul>
<h2>Faster Hook Performance</h2>
<p>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.</p>
<ul>
<li>Replaced slow in-memory tree comparisons with native git operations, reducing hook latency on large repos.</li>
<li>Added structured performance instrumentation. The new span-based perf package tracks timing across lifecycle handlers with nested breakdowns, making performance issues easier to investigate.</li>
<li>To eliminate redundant calls in the prepare-commit-msg hook, staged file lists are now cached across sessions, and go-git's <code>worktree.Status()</code> (which scans all files) was replaced with native <code>git diff --cached</code>.</li>
<li>Replaced O(N) go-git tree walks with git diff-tree in post-commit hook for faster commits.</li>
</ul>
<h2>Further Improvements</h2>
<h3>Updates to Cursor, Factory &#x26; OpenCode Agents</h3>
<ul>
<li><strong>Cursor</strong> now has full transcript analysis, enabling prompt extraction for shadow branch commit messages, summary extraction, and transcript position tracking.
<ul>
<li>Session metrics, including duration, turns, model name, and attribution, are now captured via hooks.
<ul>
<li>Thank you to <a href="https://github.com/MarkoTatic">@MarkoTatic</a> for the detailed Cursor bug reports that helped drive these improvements!</li>
</ul>
</li>
</ul>
</li>
<li><strong>OpenCode</strong> sessions now end cleanly on quit via <code>server.instance.disposed</code> instead of lingering as active.
<ul>
<li>Thank you to <a href="https://github.com/petrenk0n">@petrenk0n</a> for reporting the empty sessions issue!</li>
</ul>
</li>
<li>An E2E test runner was added for <strong>Factory</strong> sessions with full interactive flow coverage.
<ul>
<li>Thank you to <a href="https://github.com/SvenMeyer">@SvenMeyer</a> for requesting Droid support!</li>
</ul>
</li>
</ul>
<h3>Squash Merge Resume &#x26; Rewind</h3>
<ul>
<li><code>entire resume</code> parses all trailers, deduplicates sessions by ID, and sorts by timestamp to restore the correct state.</li>
<li><code>entire resume</code> on squash commits shows only the latest checkpoint instead of a confusing list of all sessions across the branch.</li>
<li><code>entire rewind</code> is fixed to pick the <em>latest</em> checkpoint in squash-merged commits, not just the first regex match.</li>
<li><code>entire rewind</code> is now able to handle squash commits properly.</li>
</ul>
<h3>Model Tracking in Checkpoints</h3>
<ul>
<li>Checkpoints now capture which LLM model was used, persisted to <code>metadata.json</code> and visible in session info. The model is resolved from agent-specific hook payloads (Claude Code's <code>SessionStart</code>, Gemini CLI's <code>BeforeModel</code>).</li>
</ul>
<h3>Session &#x26; Hook Reliability</h3>
<ul>
<li>Stale sessions are now properly cleaned up instead of lingering indefinitely.</li>
<li>Fixed a bug where hooks could silently skip files that should have been tracked across turns.</li>
<li><code>entire explain</code> no longer hangs on repos with many checkpoints.</li>
<li>Corrected inconsistent terminal behavior across different hook paths.
<ul>
<li>Thank you to <a href="https://github.com/dismory">@dismory</a> for reporting the worktree config issue!</li>
</ul>
</li>
</ul>
<h3>Setup &#x26; Developer Experience</h3>
<ul>
<li><code>entire enable</code> now supports <code>--absolute-git-hook-path</code> to set up git hooks with absolute paths to the entire binary, useful for environments where PATH resolution varies between shells or CI runners.</li>
<li>Commit signing no longer breaks the test suite for contributors who have it enabled globally.
<ul>
<li>Thank you to <a href="https://github.com/erezrokah">@erezrokah</a> for catching this and contributing the fix!</li>
</ul>
</li>
</ul>
<p>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.</p>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x0004</guid>
    </item>
    <item>
      <title>Capture Cursor Sessions with Checkpoints</title>
      <link>https://entire.com/blog/entire-dispatch-0x0003</link>
      <description>The Entire CLI now supports Cursor, capturing checkpoints and session logs. OpenCode joins the supported agents, and commits and pushes get faster.</description>
      <pubDate>Fri, 27 Feb 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Welcome to Dispatch 0x0003.</p>
<p>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!</p>
<p>With help from the community, we shipped several improvements this week, including support for our first IDE. Today, we're bringing the <a href="https://github.com/entireio/cli">Entire CLI to Cursor</a>, 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 <a href="https://github.com/9bany">@9bany</a> for your early contributions to make this possible!</p>
<p>Here's what else changed:</p>
<h2>OpenCode Support</h2>
<ul>
<li>Since this week, the Entire CLI supports OpenCode.</li>
<li>Fixed an issue with OpenCode and OpenAI Codex models not creating checkpoints when existing files were changed.
<ul>
<li>Thank you to <a href="https://github.com/jaxondk">@jaxondk</a> for requesting OpenCode support, and to <a href="https://github.com/ammarateya">@ammarateya</a>, <a href="https://github.com/Avyukth">@Avyukth</a>, and <a href="https://github.com/MementoMori123">@MementoMori123</a>, whose OpenCode PRs helped validate the design!</li>
</ul>
</li>
</ul>
<h2>Faster Checkpoints</h2>
<ul>
<li>Introduced caching and optimized work tree updates to improve performance on Git commits and Git pushes.</li>
<li>Squash-merged commits with multiple <code>entire-checkpoint</code> trailers correctly link to all their checkpoints on <a href="https://entire.io">entire.io</a>.
<ul>
<li>Thank you to <a href="https://github.com/FSM1">@FSM1</a> for reporting the squash+delete workflow gap!</li>
</ul>
</li>
<li>To fix carry-forward false positives, orphaned shadow branches are no longer created when a user replaces agent content.</li>
<li>Stale sessions no longer incorrectly condense into every commit.
<ul>
<li>Thanks to <a href="https://github.com/BootstrapBits">@BootstrapBits</a> for the detailed concurrent session race analysis!</li>
</ul>
</li>
<li>Stuck checkpoint IDs and "no active sessions" errors are resolved.
<ul>
<li>HT <a href="https://github.com/lakson-llc">@lakson-llc</a>, <a href="https://github.com/daeshawnballard">@daeshawnballard</a>, and <a href="https://github.com/wmurphyrd">@wmurphyrd</a>!</li>
</ul>
</li>
<li>O(depth) tree surgery replaces O(N) flatten-and-rebuild for both metadata branch and shadow branch writes</li>
<li>Extracted magic numbers to named constants for improved code quality.
<ul>
<li>Thanks to <a href="https://github.com/ishaan812">@ishaan812</a>!</li>
</ul>
</li>
</ul>
<h2>Further Improvements</h2>
<ul>
<li><strong>Web viewer</strong>
<ul>
<li>Added a searchable breadcrumb combobox making it easier to search and switch repos within the org.</li>
<li>In the spirit of the community, public repos are available on entire.io without logging in!</li>
<li>Fixed the tool calls section to be hidden for agents that don't report them.</li>
<li>False positive trail merge detection is fixed for new branches.</li>
</ul>
</li>
<li><strong>Fresh clone support</strong>
<ul>
<li><code>entire enable</code> now creates local metadata branch from remote when available, preserving checkpoints on fresh clones</li>
</ul>
</li>
<li><strong>Linking commits to your checkpoints</strong>
<ul>
<li>The checkpoint linking question when doing <code>git commit -m "commit message"</code> now has an "Always" option.</li>
</ul>
</li>
<li><strong>Depreciating "Auto-Commit"</strong>
<ul>
<li>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.</li>
</ul>
</li>
<li><strong>Hook Scoping</strong>
<ul>
<li>Entire only creates <code>.entire/logs/</code> folders in repos where Entire is enabled. Git hooks only run in repos where Entire is enabled.
<ul>
<li>Thanks to <a href="https://github.com/knowsuchagency">@knowsuchagency</a>!</li>
</ul>
</li>
</ul>
</li>
<li><strong>Secret Redaction</strong>
<ul>
<li>Secret redaction is improved to not redact legitimate code.</li>
</ul>
</li>
<li><strong>Unicode and Internationalization</strong>
<ul>
<li>UTF-8 truncation no longer produces garbled text for CJK/emoji characters.
<ul>
<li>Thanks to <a href="https://github.com/wasabeef">@wasabeef</a> for identifying the root cause!</li>
</ul>
</li>
</ul>
</li>
<li><strong>Session Hygiene</strong>
<ul>
<li>Gitignored files (e.g. <code>node_modules</code>) are no longer tracked in session metadata.</li>
<li>Resume sessions are now sorted by creation time and stale session files are automatically cleaned up.</li>
</ul>
</li>
<li><strong>Nix Package</strong>
<ul>
<li>Entire is available as a Nix package: <a href="https://search.nixos.org/packages?channel=unstable&#x26;query=entire&#x26;show=entire">nixpkgs/entire</a>.
<ul>
<li>Thanks to <a href="https://github.com/evanlhatch">@evanlhatch</a> for requesting this and <a href="https://github.com/DieracDelta">@DieracDelta</a> for the interim fork!</li>
</ul>
</li>
</ul>
</li>
</ul>
<p>Keep the contributions coming. Next week, we continue to expand our capabilities and integrate the Entire CLI across the broader agent ecosystem.</p>
<p>That's all for now, rebels.</p>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x0003</guid>
    </item>
    <item>
      <title>Easier Agent Integrations and Safer Checkpoints</title>
      <link>https://entire.com/blog/entire-dispatch-0x0002</link>
      <description>The Entire CLI makes it easier to add agents, improves Gemini transcript parsing, redacts secrets across stored session data, and fixes Git hook handling and checkpoint reliability.</description>
      <pubDate>Sat, 21 Feb 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Welcome to Dispatch 0x0002.</p>
<p>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.</p>
<p><strong>To bridge this gap, the <a href="https://github.com/entireio/cli">Entire CLI</a> automatically captures agent sessions, creating a semantic reasoning layer that binds agent context to Git on every push. Resulting in what we call Checkpoints.</strong>
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. <strong>Stay tuned, new agent support shipping very soon.</strong></p>
<p>And with your help, we shipped a variety bug fixes, performance improvements, and <a href="https://github.com/entireio/cli/releases">key updates</a>:</p>
<h2>Expanding Agent Integrations and Capabilities</h2>
<ul>
<li>The Entire CLI codebase has a stronger multi-agent framework, enabling faster integration of new agents.</li>
<li>The Entire CLI integration with the Gemini CLI supports full transcript parsing, Checkpointing, and session explanations.</li>
</ul>
<h2>Secret Detection</h2>
<ul>
<li>Checkpoints runs layered secret scanning using gitleaks patterns combined with entropy analysis.</li>
<li>Secrets are redacted across all persistence paths — including shadow branches, metadata, and condensed logs — ensuring sensitive data does not leak into Git history.
<ul>
<li>Thank you to <a href="https://github.com/hi120ki">Hi120ki</a>, <a href="https://github.com/andreidavid">andreidavid</a>, and <a href="https://github.com/pythoninthegrass">Pythoninthegrass</a>!</li>
</ul>
</li>
</ul>
<h2>Smarter Hook Management</h2>
<ul>
<li>Hook installation is more resilient, with automatic resolution of hook directories supporting worktrees and custom configurations using <code>git --git-path hooks</code>.</li>
<li>Existing Git hooks that the Entire CLI does not recognize are preserved.</li>
<li>External hook managers such as Husky or Lefthook are detected during <code>entire enable</code>, with a warning before anything is overwritten.
<ul>
<li>Shout out to <a href="https://github.com/AlienKevin">AlienKevin</a>, <a href="https://github.com/camwest">Camwest</a>, <a href="https://github.com/SchutteJan">SchutteJan</a>, and <a href="https://github.com/FSM1">FSM1</a>!</li>
</ul>
</li>
</ul>
<h2>Checkpoint Reliability</h2>
<ul>
<li>Subagent task file modifications are correctly captured in Checkpoints.</li>
<li>Deleted files in task Checkpoints are properly tracked.</li>
<li>Each Checkpoint produces exactly one commit, eliminating noise in Checkpoint history.</li>
<li>Git-ignored files such as <code>node_modules</code> are no longer tracked in session metadata.
<ul>
<li>Danke, <a href="https://github.com/BootstrapBits">BootstrapBits</a>!</li>
</ul>
</li>
</ul>
<h2>Improved <code>entire enable</code></h2>
<ul>
<li>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.
<ul>
<li>Big thank you to <a href="https://github.com/jayanth-iyer">Jayanth-iyer</a>, <a href="https://github.com/TyceHerrman">TyceHerrman</a>, and <a href="https://github.com/marcodicro-dp">Marcodicro-dp</a>!</li>
</ul>
</li>
</ul>
<h2>Session Restore Fixes</h2>
<ul>
<li>Sessions that previously failed to restore after repo changes (stash, pull, rebase) recover correctly.</li>
<li>Full Checkpoint history is preserved across branch operations.
<ul>
<li>HT, <a href="https://github.com/jaydenfyi">Jaydenfyi</a>!</li>
</ul>
</li>
</ul>
<h2>Empty Repo Support</h2>
<ul>
<li>Improved messaging when the Entire CLI is used in a freshly initialized repository that has no commits yet.</li>
</ul>
<p>In the coming week, we’ll focus on integrating the <a href="https://github.com/entireio/cli">Entire CLI</a> 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.</p>
<p>Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x0002</guid>
    </item>
    <item>
      <title>Checkpoints Bring Agent Context into Git</title>
      <link>https://entire.com/blog/entire-dispatch-0x0001</link>
      <description>Our first weekly dispatch with updates on Checkpoints, Gemini CLI support, secret detection, and more.</description>
      <pubDate>Sat, 14 Feb 2026 00:00:00 GMT</pubDate>
      <category>Changelog</category>
      <dc:creator>Marvin</dc:creator>
      <content:encoded><![CDATA[<p>Beep, boop. Welcome to Dispatch 0x0001, rebels.</p>
<p>This week we launched <a href="https://github.com/entireio/cli">Checkpoints</a>, 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 <a href="https://github.com/entireio/cli/releases">shipped new</a> features, improvements, and bug fixes to the Entire CLI and web UI. Here's a few of our favorites:</p>
<ul>
<li>We've improved Google Gemini CLI support — explain, rewind, and resume now work with Gemini sessions.</li>
<li>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.</li>
<li>Git hooks can now chain with existing hooks. Break less, keep working the way you expect.</li>
<li>On <a href="https://entire.io">entire.io</a>, we made the Checkpoint view easier to navigate by bringing session logs and code diffs into a single, unified view.</li>
</ul>
<p><img src="/blog/entire-dispatch-0x0001/checkpoints-new.png" alt="Checkpoints"></p>
<p>And of course, that's just a few transmissions. For various more bug fixes &#x26; improvements — see more changes to the Entire CLI <a href="https://github.com/entireio/cli/releases">here</a>.</p>
<p>This is it for this round. New dispatch every week. Boop.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/entire-dispatch-0x0001</guid>
    </item>
    <item>
      <title>Hello Entire World</title>
      <link>https://entire.com/blog/hello-entire-world</link>
      <description>Announcing Entire with $60 million seed round and shipping our first product, called Checkpoints.</description>
      <pubDate>Tue, 10 Feb 2026 00:00:00 GMT</pubDate>
      <category>Company</category>
      <dc:creator>Thomas Dohmke</dc:creator>
      <content:encoded><![CDATA[<blockquote>
<p><strong>TLDR:</strong> Today, we are announcing our new company, Entire, backed by a <a href="https://entire.io/news/former-github-ceo-thomas-dohmke-raises-60-million-seed-round">$60 million seed round to build the world's next developer platform</a>. We are also shipping our first product as open source CLI to tie agent context into Git on every push.</p>
</blockquote>
<h2>The game has changed. The system is cracking.</h2>
<p>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.</p>
<p><strong>Yet today, we still rely on a software development lifecycle built before the era of the cloud, inherently designed for human-to-human collaboration.</strong> 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.</p>
<p>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.</p>
<h2>Announcing Entire: The world's next developer platform</h2>
<p><strong>This is the purpose of our new company <a href="https://entire.io/about/vision">Entire</a>, to build the world's next developer platform where agents and humans can collaborate, learn, and ship together.</strong> A platform that will be open, scalable, and independent for every developer, no matter which agent or model you use.</p>
<p>Entire will be based on three key components: <strong>a git-compatible database</strong> that unifies code, intent, constraints, and reasoning in a single version-controlled system; a universal <strong>semantic reasoning layer</strong> that enables multi-agent coordination through the context graph; and an <strong>AI-native software development lifecycle</strong> to reinvent agent-to-human collaboration.</p>
<p>In pursuit of this <a href="https://entire.io/about/vision">vision</a>, we are proud to be <strong>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</strong>. 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.</p>
<p><img src="/blog/hello-entire-world/entire-funding-announcement-even-logos.png" alt="Entire funding announcement"></p>
<h2>Our first release: The Entire CLI to track agent context</h2>
<p>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.</p>
<p>Our first ship makes that missing context durable:</p>
<p><strong>Checkpoints are a new primitive that automatically captures agent context as first-class, versioned data in Git.</strong> 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.</p>
<p>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.</p>
<h3>How it works</h3>
<p>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.</p>
<p>Checkpoints are useful immediately:</p>
<ul>
<li><strong>Traceability</strong> - inspect the reasoning behind any agent-generated change</li>
<li><strong>Faster Reviews</strong> - review intent and constraints, not just diffs</li>
<li><strong>Better handoffs</strong> - resume work without replaying prompts or sessions</li>
<li><strong>Less token waste</strong> - agents stop repeating mistakes that you corrected in past sessions</li>
<li><strong>Multi-session and agent support</strong> - support for concurrent agentic sessions</li>
</ul>
<h3>Getting Started</h3>
<p>The best part is that you can set up Entire in two easy steps.</p>
<p>Then navigate to your repository, run <code>entire enable</code>, 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.</p>
<h2>No more stealth. We are building in the open!</h2>
<p>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.</p>
<p>Most importantly, we're releasing the <a href="https://github.com/entireio/cli">Entire CLI</a> 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.</p>
<p>Our roadmap will be directly paved by your feedback, in <a href="https://discord.gg/jZJs3Tue4S">Discord</a> and in GitHub <a href="https://github.com/entireio/cli/discussions">Discussions</a>. We're ready for it. See you there.</p>]]></content:encoded>
      <guid isPermaLink="true">https://entire.com/blog/hello-entire-world</guid>
    </item>
  </channel>
</rss>
