Entire, the Git forge from former GitHub CEO Thomas Dohmke, went live on October 26, 2026, and its pitch is blunt: the pull request was designed for humans reading diffs, and agents now write too much code for that to scale. Entire’s answer is a forge where review agents score every push and humans look at a dashboard of eval results instead of a 3,000-line diff.

I spent the weekend reading everything Entire has published since launch, including the architecture post, the pricing page and the per-run cost tables most coverage skipped. The short version is that the hosting is impressive on paper, the review model is the genuinely new idea, and the pricing is cheaper than I expected for small changes and surprisingly expensive for large ones.

What Is Entire? The Git Forge Built for AI Agents

Entire is a Git-compatible code host with three parts, as laid out in Entire’s launch post:

  • Trails replace pull requests. Eval scores sit at the top of the page and are recalculated on every push.
  • Distributed Git hosting runs on a new Git-compatible server with its own object store and transactional ref database.
  • Continuous Memory syncs agent sessions and prompts into the repository so later agents can search them.

The company is not new. Its first post, “Hello Entire World”, is dated February 10, 2026, and the Entire CLI has spent most of the year capturing agent sessions as Git checkpoints. According to Tech Times, Entire raised a $60 million seed round led by Felicis at a $300 million valuation and has grown to 50 fully remote employees. Dohmke ran GitHub for four years before stepping down in August 2025.

What changed on October 26 is that Entire stopped being a layer on top of GitHub and became a place to host code.

The bottom line: Entire is a full forge now, not a GitHub plugin, and it is betting that review is the bottleneck agents created.

How Trails Replace Pull Requests

This is the part I find most interesting, because it is the only piece GitHub cannot copy with a config change.

A Trail groups a unit of work: the goal, the discussion, the branches, every repository it touches and the agent sessions behind each change. One Trail can span several repos, so an API change and the matching web app change live in one place instead of two linked PRs.

On every push, review agents run. Entire’s launch post says they use Claude Code and Codex inside isolated cloud sandboxes from Daytona and E2B. Pre-defined agents cover code quality, security and what Entire calls “slop”. You can add your own through the UI or a .json file committed to the repo.

The Trails feature page describes three more pieces:

  • Monitors track security and “intent match” as the code changes, with the reasoning behind each score one click away.
  • Findings from review agents carry code locations, and each one has to be resolved or dismissed.
  • Gates combine checks, human approvals and CI results into explicit merge conditions.

Tech Times adds that Trails shows the last five runs and the current one as a trend line, which is a small detail that matters. A single score of 7/10 means nothing. Watching security drop from 9 to 6 over three pushes tells you an agent wandered.

My concern is the one every eval-driven workflow has. Scores are only as good as the evals, and “slop” is a vibe, not a spec. Teams that write their own review agents with concrete checks will get real value. Teams that rely on the defaults will get a nice-looking number that someone eventually learns to ignore.

Trails are the real product. The hosting is what lets Entire run them on every push.

Entire vs GitHub: Push Speed and Architecture

Entire’s headline benchmark is push throughput, measured with its open-source forgemark tool. These are vendor-reported numbers on a benchmark Entire wrote, so treat them as a direction, not a verdict.

Git push throughput (pushes per second, vendor-reported)
  • Entire 418 /s
  • Cursor 65 /s
  • Pierre 15 /s
  • GitLab 10 /s
  • GitHub 4.7 /s

Source: Entire, A Git Forge Without a Center (Oct 2026), forgemark benchmark

418 against 4.7 is where the “up to 89x faster than GitHub” line comes from. It is also six times Cursor’s forge.

Why should you care about pushes per second? Because one developer running eight parallel agents generates a push pattern no human team ever did. GitHub’s Octoverse data, which I covered in the GitHub Octoverse 2026 breakdown, says agents started more than 40% of pull requests in September 2026. Forges built for human cadence are now absorbing machine cadence.

Entire’s architecture post explains how it gets there. Repositories live in “cells”. Each cell has one PostgreSQL database for refs, where every ref update is a compare-and-swap, and a set of EntireDB nodes holding objects and packfiles. A push stages objects on several nodes, confirms them in at least two availability zones, and only then updates the ref. Fetches are served by one node from local disk.

If that sounds familiar, it should. Anthropic described a very similar split between a strongly consistent ref store and cheap object storage for its in-house system, which I covered in the Anthropic Scion analysis. Two teams arriving at the same design from different directions is a decent signal the design is right.

Entire is also honest about the tradeoffs. Replication between cells is asynchronous, so mirrors can lag, and multiple writable cells are not supported. Its deterministic simulation testing with Antithesis found a bug where a fetch could return a half-written packfile, which it fixed before launch. I trust a vendor more when it publishes the bug it caught.

Entire’s speed claims are self-measured, but the architecture behind them is documented and credible.

Entire vs GitHub at a Glance

FeatureEntireGitHub
Review unitTrails with per-push eval scoresPull requests
Push throughput (forgemark)418 /s4.7 /s
Public repositoriesNot yetYes
Self-hostingNot yetYes (GHES)
Built-in agent reviewEvery push, multiple agentsCopilot code review, per request

(Source: Entire launch post, Entire architecture post, Tech Times, October 2026.)

Hosting regions are moving fast. At launch Entire listed the US, EU, India and Australia. It then added London on October 28, according to Entire’s UK region post, followed by Singapore on October 29 and São Paulo on October 30. Repositories stay in the region where you create them unless you explicitly replicate them, which matters for teams with data residency rules.

Entire Pricing: What Agent Reviews Actually Cost

Here is the part that surprised me. According to Entire’s pricing page, hosting, Trails, session storage, Continuous Memory, agentic search and the CLI are all free during the preview. You pay only for the review agents, billed per token at the model provider’s list rate, after a one-time promotional credit you get by adding a verified card.

Usage bills to whoever owns the repository. When the balance hits zero, agents pause mid-task and resume when you top up.

Entire publishes its own estimate of what one review run costs. A run makes 8 model calls and fires on every push.

Review model1K lines10K lines40K lines
Claude Opus 5.5 (default)$0.16$0.90$3.35
Claude Sonnet 5.5$0.08$0.45$1.67
Claude Haiku 5.5<$0.01$0.13$0.49
GPT-6.1 Sol (OpenAI default)$0.08$0.45$3.14
GPT-6 Astra$0.48$2.62$18.49

(Source: Entire pricing, estimated cost per agent run excluding cache writes, October 2026.)

Now do the maths a team lead will do. Say a five-person team with agents pushes 50 times a working day at the 10K-line tier. On the default Claude Opus 5.5 that is $45 a day, roughly $990 over a 22-day month. Switch to Sonnet 5.5 and it halves to about $495. Haiku 5.5 brings it to around $143.

That is my own arithmetic on Entire’s estimates, and real costs depend on how big each push actually is. But it shows the shape of the bill. Small, frequent pushes are cheap. Big agent-generated changes on a frontier model add up fast, and the 40K-line column on GPT-6 Astra is $18.49 per push.

Compare that with GitHub, where Copilot code review draws AI credits per review on paid plans. I compared those options in the AI code review tools roundup. Entire’s per-push model reviews far more often, so it costs more in total even when each run is cheap. If you are pricing the underlying models yourself, the AI model pricing tracker has the current per-token rates.

Entire is free to host on, but per-push agent review is a real line item. Pick the review model deliberately rather than leaving the Opus default on.

Should You Move to Entire? Who It Is For

I would not move a production repository to Entire this month. Here is why, and who should try it anyway.

According to Tech Times, public repositories, self-hosting, enterprise offerings and open-source support are not available at launch. That rules out every open-source project and most regulated companies.

The safe path is mirroring. Entire can mirror a GitHub repo with GitHub as the source of truth, serving clones and fetches from regional mirrors and keeping them available during GitHub outages. Tech Times cites IncidentHub’s count of 257 GitHub incidents between May 2025 and April 2026, 48 of them major, so a read-only fallback has value on its own. Agents can push to branches under entire/unmirrored/ without touching GitHub.

If you do migrate, Entire ships an entire-migrate plugin, and its two CI launch partners handle Actions: Buildkite with bk pipeline convert and Depot with depot ci migrate.

Who should try it now:

  • Small AI-native teams where agents already write most of the code and PR review is the bottleneck. This is exactly who Entire built Trails for.
  • Teams already using the Entire CLI for session capture. The memory and search features build on data you already have.
  • Anyone curious about eval-gated merging. Mirror one private repo, write two custom review agents and watch the scores for a sprint.

Who should wait: open-source maintainers, enterprises that need self-hosting, and teams whose review problem is people, not volume.

Entire is the first serious attempt to rethink the forge around how the agentic coding workflow actually runs. It is also the same week Claude Code made auto mode the default for new sessions, which I covered in the Claude Code auto mode guide. Fewer permission prompts at the agent end and fewer diffs at the review end are two halves of the same shift.

My verdict: Entire’s Trails idea is right, its hosting is credible, and its preview is too limited for most teams to switch. Mirror a repo and judge the evals yourself.