Goodbye “Black Box” Programming: Former GitHub CEO Reshapes Human-Agent Collaboration with Entire

Core Question Answered: As AI agents generate code at unprecedented speeds, why have traditional development toolchains like Git, Issues, and PRs failed, and what kind of new platform do we need to handle this revolution?

On February 10, 2026, the tech world received a massive jolt: Thomas Dohmke, former CEO of GitHub, announced the launch of Entire, a brand-new developer platform backed by a landmark $60millionseedroundata$300 million valuation. Led by Felicis, this financing round stands as one of the largest in developer tools history. It signals a definitive shift in the industry: we are officially entering a new era defined by deep human-machine collaboration.

Entire’s vision is unequivocal: to build a next-generation developer platform designed explicitly for AI agents and human developers to work together. Unlike traditional attempts to patch legacy systems, Entire is rebuilding the software development lifecycle (SDLC) from the ground up. Alongside this announcement, they released their first open-source product—Checkpoints—a CLI tool aimed at solving the most critical issue in current AI-assisted development: the loss of context and reasoning.

As technical practitioners, we stand at a historic turning point. The speed of code generation has far outpaced human capacity to understand and audit it. This article will dissect Entire’s technical vision, explain how Checkpoints works, and explore how this new system will transform our daily workflows.

Image Source: Entire Official Announcement

When the Development System Cracks: Why We Need a “Software Assembly Line”

Core Question Answered: As AI agents become the primary producers of code, what specific collapse risks and bottlenecks do our existing “manual operation” development workflows face?

In the last few months alone, the fundamental role of a developer has been refactored. From Anthropic’s Claude Code (integrating Opus 4.6) to OpenAI’s latest GPT-5.3-Codex agentic coding model, and Cursor’s Composer 1.5, advancements in agentic intelligence have turned the flow of coding on its head. The terminal is becoming the new center of gravity, as developers prompt fleets of agents across multiple terminal windows at once.

This shift brings a harsh reality to light: Massive volumes of code are being generated faster than any human can reasonably understand.

However, the software development lifecycle we rely on today is actually a system built before the cloud era, inherently designed for human-to-human collaboration. Under this old system, cracks are rapidly widening:

• Issues: Originally designed for human planning, they lack structured, machine-readable units of work.
• Git Repositories: Never extended to version everything developers build with in the AI era.
• Pull Requests: Simply do not scale for reviewing massive monorepos.
• API Limits: Agents are being choked and throttled by centralized API capacity and rate limits every day.

As Entire CEO Thomas Dohmke puts it: “The truth is, our manual system of software production—from issues, to git repositories, to pull requests, to deployment—was never designed for the era of AI in the first place. This system cannot be retrofitted for what’s ahead.”

It is analogous to the early days of the automotive industry, where factories tried to increase output by adding more manual craftsmen, until the moving assembly line changed production forever. Today, we are at that same moment. Machines are now the primary producers of code, and we must redesign the software development “assembly line” for the era of agents.

Image Source: Unsplash

Entire’s Vision: Building an AI-Native Developer Platform

Core Question Answered: What are the three core components of Entire’s proposed next-gen platform, and how do they work together to enable human-machine collaboration?

Entire aims not just to patch tools, but to build a new home that is open, scalable, and independent for every developer, regardless of which agent or model you use. To achieve this, Entire’s architecture is built around three core components:

1. A Git-Compatible Database

Traditional Git only stores code changes. But Entire is building a database compatible with Git that unifies code, intent, constraints, and reasoning in a single version-controlled system. This means future repositories will permanently record not just “what changed,” but “why it was changed” and the decision-making context behind it. This is crucial for agents to understand historical context.

2. A Universal Semantic Reasoning Layer

This is a layer that enables multi-agent coordination through a “context graph.” In current collaboration, different AI tools are often siloed. Entire aims to break these barriers through this layer, allowing agents to share memory, understand each other’s progress, and achieve true parallel collaboration rather than reinventing the wheel in the dark.

3. An AI-Native User Interface

Finally, Entire is reinventing the software development lifecycle (SDLC) UI. This interface is not designed for humans to write code manually, but optimized for agent-to-human collaboration. It won’t be just a traditional code editor; it will be a new interaction environment capable of displaying agent reasoning processes and context graphs.

Author Reflection: Seeing these three components defined, I realize this isn’t just a tool upgrade; it’s a fundamental shift in data structures. For the past decade, we focused all our energy on optimizing the storage and flow of “code,” while ignoring the digitization of “thought processes.” Entire attempts to make “thought” itself versionable and searchable. This could be the next paradigm shift in software engineering since Git.

First Product Release: Checkpoints — Making Disappearing Context Permanent

Core Question Answered: What are Checkpoints, and how do they solve the “memory loss” problem in current AI programming by capturing agent context?

As the first step toward this vision, Entire today released Checkpoints, an open-source CLI tool. This is a powerful solution to the immediate pain points of AI programming.

The Status Quo: “One-Time” Consumption of Context

Currently, agent sessions are inherently ephemeral.

• Prompts: Live in the terminal and vanish when the session closes.
• Reasoning: Stays in context windows, disappearing once the session ends.
• Decisions & Constraints: The factors that produced the code evaporate the moment you close the window.

While Git preserves what changed, it preserves nothing about why. When an agent generates thousands of lines of code in a session, this context loss compounds exponentially. Without shared context, agents can’t collaborate effectively. They retrace steps, duplicate reasoning, waste tokens, and lose the thread of decisions made hours or days earlier.

The Solution: Turning Context into “First-Class” Data

Checkpoints introduces a new primitive: It automatically captures agent context as first-class, versioned data in Git.

When you commit code generated by an agent, Checkpoints bundles the full session with the commit:

• The transcript
• Prompts
• Files touched
• Token usage
• Tool calls

This data isn’t just a log file; it becomes the foundational write-path of Entire’s semantic reasoning layer. Developers can browse checkpoints by branch, drill into individual sessions, and trace how their codebase evolved through human-and-agent collaboration, commit by commit.

Image Source: Unsplash

Use Cases and Value of Checkpoints

Based on the documentation, we can identify several key application scenarios for Checkpoints in real-world development:

1. Full Traceability

   • Scenario: You see a strange piece of logic and no longer need to guess who wrote it or why.
   • Value: You can inspect the reasoning behind any agent-generated change directly, understanding the constraints and goals the agent was working under.

2. Faster Code Reviews

   • Scenario: Facing hundreds of lines of changes, traditional Diff reviews are inefficient and prone to missing logic gaps.
   • Value: Reviewers can inspect the “intent” and “constraints,” not just the code diff. It’s like reading the product design document before reading the code, drastically reducing cognitive load.

3. Better Handoffs

   • Scenario: Developers switch tasks or teams take over a project, requiring significant time to understand the codebase background.
   • Value: The handoff is seamless; one can resume work without replaying prompts or sessions, instantly accessing the context of previous work.

4. Less Token Waste

   • Scenario: Agents often forget previous corrections and repeat mistakes in new sessions.
   • Value: With persistent context, agents can “remember” corrections you made in past sessions, avoiding repeating errors and saving on expensive API costs.

5. Multi-Session and Agent Support

   • Scenario: Running multiple agents in parallel often leads to conflicts or fragmented logic.
   • Value: Checkpoints provides a shared memory space for all agents, ensuring they can work in parallel while staying on the same page contextually.

Technical Deep Dive: How Do Checkpoints Work?

Core Question Answered: From a technical implementation perspective, how does Checkpoints integrate with Git to store context data?

Checkpoints runs as a Git-aware CLI, designed to be unobtrusive yet powerful in your existing workflow.

How It Works

1. Automatic Capture: It automatically triggers whenever a commit generated by an agent is detected.
2. Object Writing: It writes a structured checkpoint object and associates it with that commit’s SHA (hash).
3. Code Integrity: Crucially, this process does not change the code itself. Checkpoints simply adds context as first-class metadata.
4. Branch Storage: When you git push, Checkpoints also pushes this metadata to a separate branch (defaulting to entire/checkpoints/v1).

This design creates a powerful result: you get a complete, append-only audit log inside your repository.

Data Isolation and Security

By storing context data in a separate branch, Entire ensures that:

• No Impact on Main Branch: Your main or master branch remains pristine, containing only source code.
• Traceability: Any code change can be traced back to the reasoning that produced it.
• Searchability: You can visualize and search these records via a dedicated UI provided by Entire.

Supported Agents

The goal is to support Checkpoints for every agent. The launch release includes support for:

• Anthropic’s Claude Code
• Google’s Gemini CLI

The roadmap indicates that support for Codex, Cursor CLI, and other leading agents will be rolled out in the coming months.

Practical Guide: How to Install and Use Checkpoints?

Core Question Answered: How can developers install and enable Entire Checkpoints in two simple steps to start recording AI agent context?

The installation of the Entire CLI has been designed to be as frictionless as possible, allowing developers to get up and running instantly.

Step 1: Install the Entire CLI

You can install the Entire CLI using a one-liner in your terminal. This command automatically downloads and sets up the latest script:

curl -fsSL https://entire.io/install.sh | bash

Step 2: Enable in Your Repository

Once installed, navigate to the code repository where you want to enable Checkpoints functionality and run the following command:

entire enable

Follow the prompts to configure Entire for that project. That’s it. Once configured, your agent sessions will be automatically captured in a structured, ready-to-use format.

Verification and Usage

Once set up, you don’t need to do anything else. When you develop using a supported agent (like Claude Code) and commit code, Checkpoints works silently in the background. Later, you can use Entire’s interface or future visualization tools to inspect these captured checkpoints.

Top-Tier Backing and Industry Outlook

Core Question Answered: Why did top-tier investors, including Felicis, M12, and multiple industry leaders, decide to bet on Entire, and what industry transformation do they foresee?

Entire’s cap table is stellar, serving not just as financial backing but as a vote of confidence for the consensus that “the software development paradigm must change.”

• Lead Investor: Felicis (Founder Aydin Senkut)
• Participants: Madrona, M12 (Microsoft’s venture arm), Basis Set, 20VC, Cherry Ventures, Picus Capital, Global Founders Capital.
• Angel Investors/Advisors:

  • Gergely Orosz (The Pragmatic Engineer)
  • Theo Browne (T3 Chat)
  • Jerry Yang (AME Cloud Ventures, Co-founder of Yahoo!)
  • Olivier Pomel (Datadog)
  • Garry Tan (Y Combinator)

Investor Perspectives

Aydin Senkut, Founder of Felicis, notes: “As software moves from hands-on coding to orchestrating fleets of agents, it’s becoming clear that the developer platforms we all rely on today were not built for this moment… Trying to bolt agents onto human-centric workflows is creating friction, complexity, and real bottlenecks across the ecosystem.”

He believes Entire is rethinking the platform from the ground up: AI-native, purpose-built, and designed for how software is actually made now.

Michelle Gonzalez, CVP at M12, adds: “Developer platforms have always evolved in generational waves. The next wave is emerging as AI agents are increasingly building on behalf of developers.”

Jerry Yang is even more direct: “The incumbent advantage in software development is being erased. In the era of agents, it is clear that code can no longer be hosted, reviewed, or governed in the same way.”

Author Reflection: Jerry Yang’s point strikes a chord. We often discuss “moats” in business, but when technological paradigms shift violently, old moats often become shackles that hinder innovation. Platforms like GitHub and GitLab are powerful, but if their underlying architecture assumes “humans writing code,” that massive strength becomes resistance to change in a world of “machines writing code.” Entire is attempting to build a new order on the frontier, which requires immense vision and courage.

Conclusion and Action Checklist

Core Question Answered: How should we view the launch of Entire, and what can we expect in the coming months?

The emergence of Entire is not just the release of a new tool; it is a manifesto for the fundamental refactoring of software development infrastructure. By versioning “intent” and “reasoning,” it fills the most fatal void in current AI programming.

For developers, Checkpoints is an immediately usable tool that solves the problem of context loss today. For the industry, Entire foreshadows a future of multi-agent collaboration and semantic code understanding.

Practical Summary / Action Checklist

If you are a developer or technical decision-maker, here is what you can do right now:

1. Try Checkpoints: Even if you aren’t ready to fully migrate platforms, try entire enable in an existing project to experience what it’s like to attach “memory” to your code.
2. Watch the Ecosystem: Entire plans to support more agents. If you use Cursor or other tools, keep an eye out for integration updates in the coming months.
3. Audit Your Workflow: Evaluate your team’s bottlenecks in handling AI-generated code. Is it in code review? Or in context handoff? Entire’s vision targets these exact pain points.
4. Join the Community: As an open-source project, the Entire CLI is open on GitHub. Participate in discussions and feedback to help shape this future standard.

One-Page Summary

Dimension	Key Information
Product Name	Entire (Platform) / Checkpoints (First Open-Source Product)
Core Mission	Build the next developer platform for the AI era, enabling human-machine collaboration.
Key Technologies	Git-compatible Database, Semantic Reasoning Layer, AI-Native UI.
Checkpoints Feature	Automatically captures AI context (prompts, reasoning, decisions) and links it to Git Commits.
Installation Command	`curl -fsSL https://entire.io/install.sh
Current Support	Anthropic Claude Code, Google Gemini CLI.
Funding Status	$60MSeedRound,$300M Valuation, led by Felicis.

Frequently Asked Questions (FAQ)

1. Does Checkpoints modify my source code?
No. Checkpoints only adds context as metadata and stores it in a separate Git branch. It does not touch or modify your source code files.

2. Which AI coding tools does Checkpoints support?
The initial release supports Anthropic’s Claude Code and Google’s Gemini CLI. Entire plans to extend support to include Codex, Cursor CLI, and other leading agents in the coming months.

3. Where is my data stored?
Data is stored as Git objects within your local repository and pushed to a specific branch in your remote repository. This means your data stays alongside your existing code hosting setup.

4. Is the Entire platform completely open source?
Entire’s first product, the CLI, is being released as an open-source project. The company plans to remain open and build the subsequent universal semantic reasoning layer with community feedback.

5. Why is a separate branch used for Checkpoints?
This is done to keep the code repository clean while providing a tamper-proof, append-only audit log. It ensures security while providing clear data isolation.

6. How do I review code using Checkpoints?
You can browse checkpoints by branch and drill down into individual sessions using the dedicated UI provided by Entire. The UI allows you to trace the reasoning behind code changes, not just the diffs.

7. Is this useful for small development teams?
Absolutely. Even in small teams, the volume of AI-generated code can quickly lead to context confusion. The structured memory provided by Checkpoints helps teams of any size better manage and understand agent output.

8. When will the full Entire platform be launched?
According to the announcement, the full platform is expected to launch later this year. Checkpoints is the first step toward that larger vision.