The Git Forge for Agent-Human Collaboration

After additional than a twelvemonth of hammering the iron, we’re enthusiastic to current the archetypal Git forge built specifically for agent-human collaboration. Entire is built on three primitives:

1. The Trail. Unlike the traditional drag petition example of reviewing code changes alongside a diff, Trails offers developers a heads-up display akin to an transporter pilot, alongside automated customizable evals that are scored by agents on all code push.
2. Distributed Git hosting. Entire is built on a new origin authority server compatible alongside Git, which pushes up to 89x faster than GitHub and 6x faster than Cursor Origin. You can presenter your repo and replicate it in multiple regions about the world, offering data residency and measure for agentic traffic.
3. Continuous Memory, a new method for agents and developer teams that sync sessions and prompts into the Git repository, and makes that data continually accessible and searchable to coding agents.

Plus, we are construction an open ecosystem, so developers can choice the finest tools for the job. At the start, we are partnering alongside Buildkite and Depot for Continuous Integration (CI), so your build and test pipelines keep up alongside how accelerated agents ship.

Entire is accessible for any developer today, and particularly optimized for AI-native teams and their agents. Let’s jump into the new multiverse.

Review alongside Trails

In a drag petition (PR), developers article their comments in a linear timeline, and uninterrupted integration (CI) provides a position at the base followed by the merge button. Now coding and code assessment are spamming this timeline alongside lengthy descriptions. Developers petition their coding delegate to location the code assessment agents’ feedback and afterward do another review. The drag petition has rotate into an audit log that lone the delegate reads. It does not provision the data for the developer to decide whether they can merge alongside confidence.

The Trail changes this. It brings the applicable data to the top of the leaf as eval scores, which are calculated on all push. The goal is simple: Give all the data you need to decide whether adequate loops between your coding delegate and the assessment agents have happened to accomplish a stable state. Or not, and another repeat is needed. Only whenever the confidence is high, hazard is low, and all findings are cleared, the merge should happen.

Here’s how the Trail lifecycle plant in 3 steps:

1. Spinning Up a Trail

A Trail can commencement on Entire by filing a bug study or a characteristic request. Or you can commencement a Trail direct from your agent, before or following the implementation has started, akin you would open a PR whenever you are prepared to shove code. A Trail can extend multiple repositories, so changes that pertain together are grouped together.

2. Scoring the Trail alongside Evals

When code is pushed to a Trail, Entire triggers assessment agents to assessment the commit. Think concerning it akin a panel judging an ice skating performance. Each delegate runs independently in a haze sandbox and submits a mark and a rationale. For example, throughout many of our repositories at Entire, we use Security, Slop, and Human Review Required evals. If the Slop mark is orange, you can instruct your delegate to continue correcting and pushing according to that data until the mark turns green. The final 5 runs and the current run are shown for all eval. We accept this is crucial as one-shot loops are frequently missing a crucial issue. Repeating the loops and stabilizing the scores is crucial for the achievement of agentic coding.

Each project on Entire comes alongside 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 person interface or as .json config in the repo. Under the hood, Entire utilizes Claude Code and Codex alongside the latest models, operating on secluded haze sandboxes provided by Daytona and E2B.

3. Close All Findings, Then Merge

On all push, agents can additionally come back particular findings and suggested fixes alongside distinct severity levels. Open findings are continually apparent in the Trail, during resolved findings are hidden, but can be retrieved via the menu. This way, you continually remain vigilant on what is motionless open. A finding can be addressed or dismissed, you guessed it, by agents or individual developers. You can additionally article findings and comments, fair akin in a drag request.

To create certain the merge doesn’t happen without addressing the delegate findings, Gates can be enabled per repo to define what is required before approval. These additionally contain individual approvals and passing CI checks.

CI alongside Buildkite and Depot

Continuous Integration was archetypal projected by Grady Booch all the way rear in 1991. It has been crucial to the achievement of the contemporary application betterment lifecycle, enabling teams to deploy hundreds of times per day. Now that agents compose all the code, it’s equal additional crucial to have CI as a safeguard, so the delegate isn’t changing what the immediate didn’t intend. As such, we are enthusiastic to recommendation first-class integrations of foremost CI providers into Trails, starting alongside Buildkite and Depot today.

Buildkite

On Entire, CI is configured at the project flat as frequently multiple repositories inside a project use the identical infrastructure. Once Buildkite is connected, all shove builds on either Buildkite’s or your own infrastructure. Like it would on a PR, the outcome shows up as a inspect on your Trail, and a failing build volition obstacle merging. Of course, agents can automate the complete iteration on their own, via Buildkite’s API, CLI, or MCP.

If you are a GitHub Actions user, you can migrate your workflow by operating bk pipeline change without rewriting.

Depot

Depot provides fast, dependable application shipment infrastructure for developers and coding agents, compatible alongside GitHub Actions. Depot CI runs existing workflows without GitHub in the middle.

Teams can nexus Depot from Entire in a few clicks and create a Depot document in the identical flow. Then depot ci migrate discovers your GitHub Actions workflows, promotes them to Depot CI workflows, and flags item that needs review. Companion commands assistance importing secrets and variables, so migrated workflows run inside minutes. Teams keep the workflows they’ve built and get accelerated and dependable CI from the archetypal run, billed by the second, so faster jobs disbursal less.

Host Repos in Your Region

Before distributed type authority went mainstream, the repository and its former lived on systems akin Subversion. Git changed that. Developers could create commits and branches, merge, or equal rewrite history, all locally, and reconcile afterward whenever needed. The Git protocol supported allocation and equal decentralization, but forges never lived up to it. Git distributed the repository to the client, and assorted forges centralized the server side, again and again. We accept this centralized example is not fit for the forthcoming as it lacks scalability, resilience, and authority anywhere to shop our code.

Starting today, you can create and natively presenter a repository on Entire, or mirror one from GitHub. Entire is powered by a new origin authority server, scaled alongside a distributed entity shop and a transactional ref repository that remains compatible alongside Git. Due to this architecture, Entire is the fastest Git forge in manufacturing today. According to our open-source benchmarks, pushes are up to 89x faster than GitHub and 6x faster than Cursor Origin. Users and orgs can replicate their projects and repositories throughout multiple regions, or keep it in the area they live in, for example for data residency requirements. We are live today in the US, EU, Australia, and India.

Pushes per secondUp to 89× faster

Entire418

Cursor65

Pierre15

GitLab10

GitHub4.7

Create a New Repository

To get started, you can create a new repository on Entire from our web interface or from your delegate using the Entire CLI. Repositories live inner projects belonging to an institution or a individual account. When you create a project, you choice a chief area and afterward replicate your repository throughout one or additional regions.

Mirror Your Repository (Keep GitHub as Source of Truth)

If you’d akin GitHub to remain the origin of truth, no problem. Mirror your repository by authorizing the GitHub App for Entire, afterward picking the repo and the regions on Entire. You can equal use Trails on top of drag requests, fair as you would alongside a repository natively hosted on Entire. When mirroring, shove traffic routes rear through GitHub. If there is a disruption in service, Entire volition keep serving clones and fetches from your local mirror, and your agents can keep pushing to Entire-native branches (any branch prefixed entire/unmirrored/) until GitHub is back.

Migrate Your Repository

If you’d akin to migrate your repository from GitHub, there are two options accessible to you. When mirroring in the United States, you can detach your mirror by beginning the repository’s settings, afterward clicking Detach from GitHub, and choosing the project to move it into. Or, if you’d akin to migrate immediately from GitHub without mirroring, you can use the entire-migrate plug-in which takes attention of the process. And, of course, you can continually fair fetch from GitHub and shove to Entire, on your local device or as part of your CI/CD workflow.

Turn Sessions Into Continuous Memory

Every day, developers and agents create decisions, detect constraints, try new approaches, and study what plant during construction features and squashing bugs. But most of that cognition disappears whenever the meeting ends. When you commencement a new session, your delegate opens a new environment opening and has to re-learn everything which is not lone dilatory but additionally expensive.

Today, we are introducing a new idea that we are calling Continuous Memory. Think concerning it this way: CI brings code together. CD ships it. Continuous Memory carries the understanding forward. The repository is the lone recollection your delegate should need.

Two new commands in the Entire CLI create Continuous Memory possible: entire-graph, which maps how your code fits together and in our evaluation saved up to 71% on tokens, and entire-brain, which indexes your delegate sessions and attaches them to the chart to create durable memories that the delegate can recover faster than grepping through the codebase. Both plugins are open origin and local first, and they’re designed to activity together: entire-brain builds on entire-graph’s map of your code.

A Map of Your Codebase

entire-graph hands your delegate a precomputed map of your Git repository: classified code hunt affirmative definitions, callers, types, routes, and alter impact, all alongside file:line locations. The built-in analyst parses the repository locally alongside tree-sitter and makes no network requests, example calls, or API-key lookups.

entire-brain

entire-brain creates a durable recollection tier for your repository. This allows agents to continually have the correct environment at the correct time, aka the “why” rearward the “what changed.” Under the hood, entire-brain indexes entire-graph’s map of your code and binds it alongside former delegate sessions that are recorded in your Git former via the Entire CLI.

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 all visitant and test, during entire-brain gives your delegate the intent rearward the current logic, the fixes already shipped and why, or what tests bankrupt the final period person changed it.

entire-brain can additionally be connected to the Entire backend, enabling your team’s delegate memories to live in one shared area alternatively of idiosyncratic machines. Every Trail afterward shows the memories that the delegate created, so reviewers see what decisions the developer made and what facts the delegate learned. To get started, set up entire-graph and entire-brain in your repository.

Join the Rebellion

A twelvemonth following we started, we couldn’t be additional enthusiastic concerning what Entire has already rotate into and what our agents are operating on next. But construction a new developer phase can lone be done in collaboration alongside the community. So we desire to comprehend from you, study from you, and enhance the merchandise alongside you. Try it out. Tell us what you affection or desire improved via Discord so we can scheme the forge of the future, together.

Let’s attack during the metal is hot. Welcome to the rebellion.