Entire's Git Forge Uses Eval Scores to Help Developers Merge AI-Generated Code

According to InfoQ, Entire, a Git forge designed specifically for collaboration between human developers and AI coding agents, is led by Thomas Dohmke, the former GitHub CEO, and reimagines the pull request model for an era where agents generate and iterate on code at high speed. The platform addresses a critical failure mode in traditional version control: pull request timelines have become audit logs that only agents read, leaving developers with little basis to decide whether a merge is safe.

What Happened

According to InfoQ, Dohmke frames the architectural shift in explicit terms: GitHub and GitLab were built to centre human-to-human collaboration around asynchronous code review and version control, but a multi-agent forge must centre instead on the asynchronous orchestration, versioning, and auditing of AI agents working alongside humans. This distinction is not semantic. Traditional source control assumes a human author and human reviewer at each step, a design that breaks down when coding agents operate at speeds that exceed human review capacity.

Entire's core feature, called trails, directly addresses this gap. Per InfoQ, trails surface eval scores that update on every push, covering code quality, security, and what Entire calls "slop," along with a determination of whether human code review is required. A review agent running in a cloud sandbox evaluates each change and returns a score with a rationale. If a score comes back orange, developers can send the code back to their coding agent for another iteration. This is not a single-pass review. InfoQ reports that Entire tracks the last five runs alongside the current one specifically because one-shot loops are often missing a critical issue, and repeating loops to stabilize scores is treated as essential rather than optional.

The enforcement mechanism is strict. According to InfoQ, all review findings must be either resolved or closed before a merge is allowed, and teams can configure repository-level Gates that define the conditions required for approval. This converts what has traditionally been a soft recommendation in human code review into a hard checkpoint in the merge pipeline. The eval scores provide not just a pass-fail signal but a structured reasoning layer that surfaces why a change is or is not ready.

Entire introduces a second foundational concept called continuous memory, implemented through two open-source tools, entire-graph and entire-brain. Per InfoQ, entire-graph builds a precomputed map of the Git repository including ranked code searches, definition and callers, types and routes, and more. Entire-brain creates a persistent memory layer by combining the codebase map with previous agent sessions and information recorded in Git history. This allows agents to always have the right context at the right time, what the company describes as the "why" behind the "what changed.Attribute the quote to Haimantika's Hacker News comment responding to a discussion about programming languages and tools, rather than presenting it as part of the company's official description of continuous memory.

The platform is built on a distributed architecture that InfoQ reports enables pushes up to 89 times faster than GitHub. Entire also integrates with CI systems including Buildkite and Depot, meaning developers can anchor agent-generated code changes to existing continuous integration pipelines without rearchitecting their deployment infrastructure.

Why It Matters

A forge that forces resolution of every flagged finding before merge and logs eval scores per push rather than relying on a single human glance at a diff is effectively building compliance infrastructure directly into version control rather than treating governance as an external audit layer.

This matters because the industry has moved faster on agent capability than on agent governance. The MachineHours AI Acceleration Index puts capability at 62 against an employment sub-score of just 18, a gap that reflects tools outpacing the human processes meant to supervise them. Entire is one of several new entrants - alongside Zed DeltaDB, Anthropic Scion, East River Source Control, Cursor Origin, and Radicle - competing to define what agent-native source control compliance looks like. The design Entire chooses, and which approach the market standardizes on, will shape not only how code gets reviewed but which organizations can adopt AI agents at scale. Governance-first infrastructure may become as foundational to agent-era development as CI/CD pipelines are today. The equity implications of AI developer tool adoption will likely follow whichever model wins out.

Background

Traditional source control, built around GitHub and GitLab, assumes a human author and human reviewer at every step. This model is documented extensively in MachineHours' guide to AI coding tools and the transformation of software development. As coding assistants reached majority adoption among professional developers - detailed in AI Coding Reaches Majority Adoption - the pace of code generation began outstripping the review capacity built into that human-centric model, creating exactly the audit gap Entire is now targeting. The problem is acute because the traditional pull request workflow was designed for humans reviewing humans, not for agents reviewing agents or humans reviewing agent-generated code at scale.

What to Watch

Whether eval-score gating becomes a standard expectation for enterprise repositories, rather than a differentiator unique to Entire, will determine how quickly this security model spreads beyond early adopters. Competing forges including Cursor Origin and Anthropic Scion are pursuing related but distinct approaches to agent governance, and which design enterprises standardize on could shape procurement decisions for years. Watch also for how continuous memory tools like entire-graph and entire-brain perform under real audit scrutiny, since persistent context across agent sessions raises its own questions about what sensitive history gets retained, surfaced, and audited. The retention of reasoning across sessions is a feature for development velocity but a potential vector for information leakage if not carefully governed.

Further reading and context

• The Agentic Enterprise — When AI Agents Run the Workflow
• MCP Goes Open — The Linux Foundation Takes Stewardship of AI's Universal Standard