Some coincidences aren't. Within four months, two people who helped make GitHub the centre of gravity of the software world raised money to explain, each in their own way, that the foundations no longer hold. Scott Chacon, GitHub co-founder and author of Pro Git, with GitButler. Thomas Dohmke, GitHub's CEO for four years until he left in August 2025, with Entire.
Their diagnosis fits in one sentence: Git was designed for humans mailing patches to a list — one developer, one branch, one terminal, one linear flow. Agents broke every one of those assumptions at once.
The diagnosis is right. What follows is more interesting than the throughput numbers, because the two of them, attacking different layers, end up pointing at the same thing.
What Entire attacks: the pipe
On 8 July 2026, Entire opened the preview of its Distributed Git Network, with active regions in the U.S., the European Union and Australia. The mechanism is deliberately unintrusive: in one step you create a regional mirror of an existing GitHub repository. The code stays on GitHub; it's the agents that clone and pull from the nearest mirror. The read traffic — massive, concurrent, generated by agents that have no reason to wait — stops hammering the central server.
Dohmke frames the argument by quoting Linus Torvalds, who said in a 2007 talk: "If you're not distributed, you're not worth using." His reading: Git was distributed by design, centralised hosting re-centralised it, and in the agent era that centralisation becomes visible again as rate limits, latency and outages.
The figures published by the company:
Entire (announced figures, obtained in simulation) clones ....... ~570,000 / hour (1 repo, 200 clients, 4 EU cities) pushes ....... 586 / second = ~2.1M / hour (single repo or branch) mixed ........ ~470 operations / second (clone + push loop) Cursor Origin (rival's own claim, as cited by Entire) pushes ....... ~81,360 / hour
A word of caution, and it comes from the coverage itself. These are simulations, not production measurements: 200 simulated clients shallow-cloning from Frankfurt, Paris, London and Dublin. The comparison with Cursor Origin is a comparison drawn by Entire, using a figure Cursor claimed. And as L'Usine Digitale notes, the real test isn't the benchmark, it's the ramp-up: holding the load in real conditions while building out the infrastructure. Entire says it will open-source both the Git backend and the benchmark suite — that is the right answer to the objection, and it deserves to be judged on delivery.
For context: Entire is five months old, with a $60 million seed round led by Felicis (alongside Madrona, M12 — Microsoft's venture arm, which is not nothing here — Basis Set Ventures, Jerry Yang and Garry Tan), a $300 million valuation and more than 40 employees across nine countries. Native hosting for new repositories is promised "in the coming months", with full decentralisation as the goal.
What GitButler attacks: the primitives
Chacon is going after a different layer. Not the pipe, but the shape a change takes. GitButler raised $17 million in a Series A led by Andreessen Horowitz in April 2026, and shipped the technical preview of its command line, but: stacked branches, multitasking, undo, reorganising changes — usable by a human or an agent alike.
His framing of the problem is, to my mind, the better of the two:
"Developers don't struggle because they can't write code. They struggle because context fragments across tools, across people, and now between people and agents. The real difficulty isn't generating changes — it's organising, reviewing and integrating them without creating chaos."
The reception, on the other hand, was rough — and it's worth reporting honestly, because it is instructive. On the forums, the dominant reply fits on one line: "Git isn't SVN, and these problems are already solved." Several voices point out that the real target isn't Git but GitHub — the former being a commons that is hard to dethrone, the latter a commercial platform that can be attacked.
Above all, the distrust crystallised around one very concrete detail: on installation, GitButler placed a pre-commit hook that blocks git commit and redirects to but commit, with no opt-in. Chacon stepped in to explain that it's an architectural necessity tied to how the tool manages parallel branches. The explanation is reasonable; the lesson stands. On critical infrastructure, tolerance for a default installed without consent is zero. That reaction says more about what the market will accept than any benchmark.
A notable side effect: the discussion mostly benefited Jujutsu (jj), an open-source version control system that uses Git as its backend, whose automatic-snapshot model fits AI-assisted development rather well — iterate freely, tidy up afterwards. Several developers describe pairing it with a coding agent through a hook that snapshots on every file change.
Two layers, one diagnosis
These two projects don't really compete. Dohmke is dealing with where the bytes travel; Chacon with the shape a modification takes. You can easily picture both in the same toolchain.
What matters more than either product is the bare fact: two people who built the current world walked away from it having concluded, independently, that its foundations are misaligned. When insiders of that calibre go and raise $77 million to rebuild a layer they made dominant themselves, that isn't a weak signal.
When the pipe stops being the limit, the limit moves up a layer
Take the number seriously. 2.1 million pushes per hour into a single repository. Assume it holds in production.
Who reads that?
The question isn't rhetorical. The problems teams working with agents already document are 10,000-line merge requests, the difficulty of establishing who authored a change, conflicts between branches worked in parallel by several agents. Removing the rate limit doesn't remove the constraint: it moves it. The scarce resource stops being throughput and becomes attention — and decision.
Infrastructure that is twenty-five times faster, on top of which nobody knows what shipped, isn't progress — it's acceleration. This isn't an argument against Entire: it's precisely why Entire isn't only a network, and we'll get to that.
One commenter quoted by Developpez asks the question that will outlive the benchmarks: as agents produce dozens of commits an hour, does the commit still mean anything as a unit of human work? Honestly, no. The unit that keeps its meaning is coarser: a shipped feature, a version validated on an environment. The commit goes back to being what it was meant to be in the first place — an implementation detail.
The unexpected agreement: what's missing is the why
This is where the two converge, and it's by far the most interesting part of these announcements.
Entire's foundation isn't the network. It's a semantic memory layer that captures every agent session, prompt and tool call and files them in the repository next to the code. It powers three features: Entire Blame (trace a line of code back to the conversation that produced it), Entire Review (send a branch to several agents in parallel for an intent-aware review), and a semantic search that answers "why does this code exist" rather than only "what changed". Dohmke puts it bluntly:
"Session logs are now the second most important artifact in software development, and they belong in the repository alongside the code."
Chacon, for his part, describes context "fragmenting across tools, across people, and now between people and agents", and is aiming at tools that fold "conversations and decisions into the repository's history".
Two paths, one conclusion: in the agent era, code is no longer the scarce artefact. It regenerates on demand. What doesn't regenerate is intent — the business constraint that forced the choice, the trade-off that was settled, what was tried and ruled out.
Where we disagree
We've been building Survol on that premise from the start, so we're not going to pretend we aren't pleased to see these two say it out loud. But we draw different conclusions on three points, and they're worth stating plainly.
A session log is a trace, not a decision. A trace tells you what happened. A decision tells you what was ruled out, by whom, and why. You can search a trace; you can't steer with one. A prompt records what someone asked for at a given moment — that is not the same thing as a commitment a team made, dated, discussed, possibly contested. The difference isn't cosmetic: the first is an execution artefact, the second is a governance artefact.
Exhaustive memory is not usable memory. Session logs grow faster than the code, and their value decays over time. A product decision fits in ten lines and stays true for two years. An honest objection to our own argument: semantic search is exactly Entire's answer to that problem, and it's a good one. Still, searching a history and reading a list of settled decisions don't take the same effort — or the same skill.
On where that memory should live, we made the opposite call — and Dohmke's argument is a good one. Filing the history next to the code guarantees it survives a change of tooling and is cloned along with the repository. That's solid. Our own choice runs the other way: the customer's repository belongs to the customer, and an execution history growing inside it is a form of appropriation of their code space. In our model the execution report is an object in the tool, the summary goes into the body of the merge request — versioned at the source-control provider, where the decision to merge is actually made — and the markdown archive in the repository exists as a per-product option, off by default. That's a trade-off, not a truth: both positions can be defended.
Finally, one thing neither of them addresses — and that isn't a criticism, it isn't their layer. A session log documents an execution that has already happened. What decided it — the specification, the trade-off, the organisational constraint — happens before, and often nowhere at all: in the head of whoever wrote the prompt. That's the layer we build for, and it stays useful whoever wins the battle below.
What this changes for a team, this week
- The mirror pattern is low-risk. The code stays on GitHub; you add a regional copy for reads. If your agents are hitting rate limits, joining the waitlist costs nothing and commits you to nothing. That's a far smaller step than switching Git client.
- Don't confuse a throughput problem with a legibility problem. Simple test: take your last twenty merged changes and try to say, for each one, why it was made. If you can't, no infrastructure will fix that.
- The venture-capital caveat is legitimate, and it applies to everyone. ZDNet puts it soberly: you always take on risk when you depend on a service that could lose its funding. A $300 million valuation will have to answer for itself one day. The practical rule fits in two questions: does it leave my code where it is, and what happens if I leave?
- Region is not jurisdiction. Entire highlights data residency and sovereignty. L'Usine Digitale points out what the reasoning leaves out: the company is based in Seattle, and therefore subject to U.S. extraterritorial law. Hosting in Frankfurt doesn't change that. For a European IT department, that distinction matters.
What we take away
- Two GitHub alumni are attacking two different layers: Dohmke the transport (regional mirrors, decentralisation), Chacon the primitives (stacked branches, the shape of a change). They aren't competing.
- Entire's figures — 570,000 clones/hour, 2.1 million pushes/hour — are simulations announced by the company. Open-sourcing the backend and the benchmarks is the right answer; the ramp-up remains the real test.
- Removing the rate limit moves the bottleneck up to attention and decision. At that rate, the commit stops being a meaningful unit of work.
- The most important point of agreement isn't technical: both argue that the scarce artefact is now the intent behind the code. We share that diagnosis.
- We differ on the form (a trace is not a decision) and on the location (the customer's repository belongs to the customer). Those are defensible trade-offs on both sides, not truths.
Git took twenty years to become the invisible infrastructure the whole of software development rests on. Its successor, whoever that turns out to be, will have to solve unprecedented technical problems and convince a community as suspicious of monopolies as it is attached to open standards. On that ground, the contest will be decided less by 2.1 million pushes per hour than by an older question: who owns the history of the code?
Sources: SiliconANGLE, 8 July 2026 · GeekWire, 8 July 2026 · L'Usine Digitale, 9 July 2026 · ZDNet, 10 August 2026 · Developpez, 13 April 2026. All performance figures quoted are those communicated by the companies concerned. Scott Chacon's remarks are rendered here from the French-language account published by Developpez, and may differ in wording from his original statement.
