• 7 min read

Agent-First Git, Automated Evals: Pull Request Dead in 2026?

tl;dr

The pull request isn't dead, but it is being split. Agent-scored evals now own review work while the integration gate stays, and most teams still keep pull requests for accountability.

Featured image for "Agent-First Git, Automated Evals: Pull Request Dead in 2026?"

Over 40% of pull requests on GitHub now start with an agent’s first draft, up from 17% just six months ago. That number comes straight from GitHub’s own Octoverse data, and if the trend holds, we’re looking at a majority of PRs being agent-authored by year’s end. The pull request isn’t dead — but it’s being hollowed out from the inside.

What Triggered This Shift Toward Agent-First Git?

The volume problem is real and measurable. Anthropic reported its monorepo went from roughly 2,500 merged changes per day in May 2026 to over 30,000 per day by September, and source control became its biggest development bottleneck — so much so that the company built its own in-house version control system called Scion. When the organization that builds Claude says Git is the constraint, the rest of us should pay attention.

GitHub’s data shows the same acceleration from the other side: per GitHub’s Octoverse data cited in October 2026, over 40% of pull requests started with an agent’s first draft by September 2026, up from 17% in March 2026. That’s a 23-percentage-point jump in six months, or roughly 3.8 percentage points per month.

The bottleneck has moved. It used to be writing code. Now it’s reviewing code that agents wrote faster than any human can read. Traditional pull-request review assumes human speed, but agents act at machine speed. That mismatch is why new platforms are emerging that put automated evaluations directly in the push-to-merge path instead of treating them as optional assistants.

How Does Entire’s Trails Replace the Pull Request?

Entire launched publicly for all developers on October 26, 2026, replacing pull requests with Trails, a feature where agent-scored evaluations run on every code push instead of traditional diff-based review. Entire’s launch announcement confirms the public availability date and the Trails mechanism.

Trails presents the proposed idea, the agent trace, and the session outcome as first-class artifacts for review alongside the code. Instead of inspecting a line-by-line diff, developers validate agent-generated evaluations before a merge. The default agents cover security, slop, and “human review required” — that last one is a triage call on where human attention goes, made by a model. Custom agents can be defined in the UI or as JSON committed to the repo.

The design shifts the default task from reading diffs to validating eval scores. Entire’s position is that if Trails scores pass, developers can merge without reading every line. That’s a bold claim, and it rests entirely on the quality of those evaluations — which brings us to the accountability problem.

What Are the Real Performance Claims and Pricing?

Entire claims its Git hosting delivers pushes up to 89 times faster than GitHub and six times faster than Cursor Origin; these are vendor benchmarks and have not been independently verified. The company also claims its Continuous Memory feature reduces agent token use by up to 71% in its testing. Both figures come from Entire’s own benchmarks and deserve skepticism until outside testing confirms them.

The pricing model is notable: Entire is free to use, but customers pay for tokens consumed by review agents rather than per-seat licensing, with new users starting with a $100 credit. This ties cost directly to agent compute usage rather than headcount — a different model from GitHub’s seat-based pricing. For teams running many agents, the token bill could exceed per-seat costs; for lighter usage, it could be cheaper. There’s no published per-token rate in the launch materials, so you’ll need to test your actual workload.

Community reaction on daily.dev was split: 25% positive, 30% mixed, and 45% skeptical. The skepticism centers on whether reviewing agent sessions is actually valuable, plus questions about the product’s premise, pricing transparency, and marketing tone. The daily.dev community breakdown shows the same split.

PlatformPricing ModelReview MechanismTarget Audience
EntireFree platform + token-based agent costs ($100 starting credit)Trails: agent-scored evals on every push, merge gatesTeams adopting agent-first workflows, high push volume
GitHub CopilotPer-seat (Pro, Pro+, Max, Business, Enterprise)Copilot code review: Lite/Balanced/Max effort levels, approvals GAExisting GitHub Enterprise customers, teams wanting integrated review
AVP (Murmell)Open sourceProves every change on exact head of main before landingSmall teams running many agents on monorepos, Git-compatible deploys
Traditional PRPer-seat (GitHub/GitLab/Bitbucket)Human diff review + CI checksTeams with low agent adoption, regulatory audit requirements

Why Don’t Agent Merge Gates Publish Error Rates?

Here’s the uncomfortable truth: none of the agent merge gate vendors — Entire, Cline, Paperclip, GitHub HydraFusion — publishes false-positive or false-negative rates for their automated checks. This comes from New Runtime’s analysis, which argues that the human reviewer’s new job is owning that unquantified error rate.

When an agent-scored gate blocks a merge, you don’t know how often it’s wrong. When it passes, you don’t know how often it misses something critical. The gate is a probabilistic model, and without published error rates, the human approver is accepting liability for an error rate they cannot measure. That’s not a theoretical concern — it’s the new accountability surface.

New Runtime’s analysis notes that Entire’s default agents cover code quality, security, and “slop,” while Cline Desktop adds a Changes pane with per-file diffs and PR merge status, Paperclip adds a GitHub review status check with cost ledger and budget policies, and GitHub’s HydraFusion uses medium reasoning effort for drafts and high effort for review with Cascade and Critique workflows. None of them publishes accuracy data.

This creates what I call the Error Rate Ownership pattern: teams now have to measure and own their review gates instead of reading every diff. Until a gate publishes its false-positive and false-negative rates, the human approver is accepting liability for an error rate they cannot measure. Treat agent-scored merge gates as uninsured infrastructure.

Are Teams Actually Abandoning Pull Requests?

Despite the hype, the data says most teams are keeping pull requests in some form. GitQuick’s preprint review of 50 documents from 31 organizations found that most proposed responses to AI-agent development still keep pull requests in some form; only Zed reported using a replacement in practice. The research separates five roles that pull requests often combine: integration, review, rationale, accountability, and external contribution. Several proposals moved review or rationale into agent conversations and session records, but the integration gate remains.

This makes sense. A pull request is more than a diff viewer — it’s a concrete record of what changed, who approved it, and which checks passed. A faster code generator doesn’t remove that need. The weakness appears when the patch is no longer the whole story: a reviewer may need to understand the original request, the agent’s plan, which tests were selected, what changed after a failure, and whether the latest push invalidated an earlier review.

Murmell, a two-person startup running many coding agents on one monorepo, open-sourced AVP (Agent Versioning Protocol) and reportedly saw its pull-request CI runs fall from 104 per day to 4. But notably, every AVP landing is still an ordinary Git commit, so GitHub and deploys don’t change. They’re not abandoning the PR model — they’re compressing the CI feedback loop that feeds it.

What Does This Mean for Your Review Workflow?

GitHub isn’t standing still. GitHub Copilot code review Max effort level entered public preview on October 28, 2026, and Copilot approvals became generally available the same day; both are available on Copilot Pro, Pro+, Max, Business, and Enterprise plans. Max runs several independent review agents across models from different providers, then passes findings to an aggregation agent that reconciles them — a multi-agent approach that mirrors human review practice. Copilot approvals count toward required approvals exactly like a human reviewer’s would.

But GitHub hasn’t published Max’s false-positive or false-negative rates either. The company claimed Max “posted the highest F1 score on ReviewBench for high-severity issues” but didn’t publish the score, the scores of other systems, or the test set details. Without that transparency, you’re still owning an unquantified error rate.

For teams evaluating this shift, the decision framework is straightforward: if your agent-authored PR volume is low, traditional review with AI assistance (Copilot Balanced, Claude Code Review) works fine. If you’re seeing the Anthropic-scale surge — thousands of merged changes per day — you need infrastructure that can handle the throughput, whether that’s Entire’s distributed Git hosting, AVP’s queue-based landing, or gstack’s merge-train eval gates that share one full gate across several ready PRs.

The pull request isn’t dead. It’s being split: the integration gate stays, but the review work migrates into unobservable agent sessions. Your job isn’t reading diffs anymore — it’s owning the error rates of the gates you trust. Until vendors publish those rates, every merge approval is a leap of faith.

What’s your team’s actual agent-authored PR percentage right now? That number, not the hype, should drive your tooling decision.