Entire - Git-Native Context for AI Agents, $60M Seed

TL;DR

TL;DR: Entire is a developer platform that captures AI coding-agent sessions as first-class, versioned Git metadata (called Checkpoints), shipping an open-source CLI now and a broader context graph coming soon. Launched on February 10, 2026 with a $60M seed at a $300M valuation, led by ex-GitHub CEO Thomas Dohmke and backed by Felicis, Madrona, and M12.

Source and Accuracy Notes

• Launch announcement: entire.io/blog/hello-entire-world
• Documentation: docs.entire.io
• Structured docs index: entire.io/llms.txt
• HN discussion: 611 points, 577 comments on a URL-only submission

The HN post itself is a link submission (no embedded text). The full founder narrative comes from the blog post, llms.txt, and the agent-integration docs. All technical details below are drawn from those primary sources as of the 10 February 2026 launch.

What Is Entire?

Entire is a developer platform built around a single claim: today’s software development lifecycle was designed before AI agents existed, and the cracks are forming. The product is shipping in two pieces:

1. Entire CLI (open source) — a Git-aware CLI that captures AI agent sessions on every commit, attaching the transcript, prompts, files touched, token usage, and tool calls as structured Git metadata called Checkpoints.
2. Entire platform (in development) — a git-compatible database that unifies code, intent, constraints, and reasoning in a single version-controlled system, plus a semantic reasoning layer for multi-agent coordination.

The thesis: when agents generate hundreds or thousands of lines per session, the context that produced those lines is the most valuable thing in the workflow. Git preserves what changed, but nothing about why. Entire makes that “why” durable, queryable, and shared across agents and humans.

The company is led by Thomas Dohmke, former GitHub CEO, with a $60M seed round led by Felicis. Madrona, M12, Basis Set, 20VC, Cherry Ventures, Picus Capital, and Global Founders Capital participated, alongside individual backers Gergely Orosz, Theo Browne, Jerry Yang, Olivier Pomel, and Garry Tan.

The Checkpoints Primitive

Checkpoints are the foundational write-path of the platform. The mental model:

• On every commit generated by an agent, the Entire CLI writes a structured checkpoint object and associates it with the commit SHA.
• The diff itself is unchanged. Entire only adds context as first-class metadata.
• When you push your commit, checkpoints also sync to Entire’s web dashboard, where you can browse them by branch, drill into individual sessions, and trace how the codebase evolved through human-and-agent collaboration commit by commit.

This matters because agent context loss compounds fast. Without shared context, agents retrace steps, duplicate reasoning, waste tokens, and lose the thread of decisions made hours or days earlier. A checkpoint bundle is the unit that future agents (or humans doing review) can load to understand what a previous session actually decided.

Repository-Specific Setup Workflow

Step 1: Install the Entire CLI

The CLI is distributed as a single Go binary. Install via the official install script:

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

This drops the entire binary on your PATH. Verify with:

entire --version

Step 2: Authenticate and link a repository

entire auth login
cd /path/to/your/repo
entire init

entire init registers the current repo with your Entire account and installs the agent hooks that drive checkpoint capture. The hooks are Git-aware: they fire on git commit and inspect whether the commit was produced by a supported agent.

Step 3: Run a Claude Code or Gemini CLI session

Entire currently ships first-class support for two agents at launch:

• Anthropic’s Claude Code (Claude Opus 4.6 at launch)
• Google’s Gemini CLI

Run a normal session. When you commit generated code, the CLI captures the full transcript alongside the commit SHA. No special flags, no commit message changes — checkpoints are written silently in the background.

Step 4: Inspect a checkpoint

entire log --checkpoint

This shows recent commits with their associated checkpoint summaries. To drill in:

entire checkpoint show <commit-sha>

The output includes the session transcript, files touched, token usage, and the tool call sequence. You can also browse the same data in the Entire web dashboard.

Step 5: Roll back to a checkpoint

Because checkpoints are Git-addressable, you can checkout the state of any session:

entire checkpoint restore <commit-sha>

This restores the working tree to the code as it existed at that commit, with the checkpoint context available for the next agent session to load.

Supported Agent Integrations

At launch, Entire CLI ships with two agents; the docs (docs.entire.io/agents/) list the full integration matrix:

| Agent | Status at launch | |---|---| | Anthropic Claude Code | Shipped | | Google Gemini CLI | Shipped | | OpenAI Codex | Coming soon (now supported) | | Cursor CLI | Coming soon (now supported) | | GitHub Copilot CLI | Coming soon (now supported) | | OpenCode | Coming soon (now supported) | | Pi (Preview) | Coming soon (now supported) | | Factory Droid | Plugin | | External agents | Plugin SDK |

The plugin SDK is the official extension path. If you maintain a third-party agent, the entire agent plugin spec (docs.entire.io/agents/external-agent-plugins.md) defines how to wire it into checkpoint capture.

Agent Hooks — The Integration Layer

Entire’s hook system is split into two layers:

• Agent hooks — declared inside the agent’s own configuration (Claude Code’s settings.json, Gemini CLI’s hook config, etc.). These let the agent notify Entire of session lifecycle events: start, transcript update, end, commit.
• Git hooks — installed by entire init. These fire on post-commit and post-push to capture the resulting commit context.

The combination is what makes checkpoints durable. Agent hooks feed transcript data into a session buffer; Git hooks attach that buffer to the commit SHA on every push. The end result: every agent-authored commit has its reasoning attached, regardless of which agent produced it.

Deeper Analysis

Why a Git-Native Primitive

A reasonable question: why not just store everything in a database? The blog post makes the case explicitly: Git is the only system that already sits in every developer’s workflow. Adding a checkpoint to a commit SHA means the context is colocated with the code, follows the same branching model, and inherits Git’s offline and distributed properties. A side database would require explicit sync, would drift from branches, and would not be addressable by tools that already speak Git.

This is also why the team chose to ship the CLI as the first product. The CLI is the lowest-friction surface for a primitive that needs to work even when you are offline, on a plane, or in a sealed environment.

The Context Graph Thesis

Checkpoints are described as the “foundational write-path” of a larger system: a context graph that connects transcripts, code changes, intents, constraints, and reasoning across sessions and branches. The long-term pitch is that this graph becomes a queryable substrate for multi-agent coordination — an agent about to start work on a file can ask the graph “what decisions have shaped this file across the last 30 commits and 5 branches?” and get a structured answer.

That is a much larger vision than the CLI shipped on day one, but the CLI is designed to be the data source for that graph. Every checkpoint you write today is a node the graph will be able to read tomorrow.

Investor Signal

The investor list is unusually heavy for a seed: Felicis, Madrona, M12 (Microsoft’s venture fund), Basis Set, 20VC, Cherry Ventures, Picus Capital, Global Founders Capital, plus individual checks from Gergely Orosz (The Pragmatic Engineer), Theo Browne (t3.gg), Olivier Pomel (Datadog CEO), Jerry Yang (Yahoo co-founder), and Garry Tan (Y Combinator president). At a reported $300M valuation on a $60M seed, the round is structured to give the company a long runway to build the platform layer without near-term fundraising pressure.

Practical Evaluation Checklist

When you try Entire, the things that tell you whether the primitive is working for your workflow:

• [ ] A checkpoint appears in entire log for every agent-authored commit
• [ ] The checkpoint’s transcript includes the prompts you actually sent, not a truncated summary
• [ ] Files touched in the checkpoint match the files in the diff
• [ ] Token usage in the checkpoint matches what the agent reported
• [ ] entire checkpoint restore puts the working tree back into a clean, buildable state
• [ ] Checkpoints survive a git push to a remote — they are not just a local artifact
• [ ] An unrelated human commit (you typing in an editor) does not produce a checkpoint, or produces an empty one

If any of these fail, the CLI has a configuration gap rather than a fundamental issue. The hooks system is the most likely culprit.

Security Notes

Checkpoints capture the full transcript of an agent session. That means:

• API keys, secrets, and credentials pasted into prompts will be captured. Use a secret redaction system (Entire ships user-defined redaction rules — see the blog post on that topic) before relying on checkpoints for production work.
• PII in transcripts becomes a node in the context graph. Treat the checkpoint store with the same access controls as your source code.
• Agent output can be sensitive. A checkpoint of a security review session, for example, contains the same details an attacker would want. Apply the same review policies you would to a code review.

The blog post on user-defined redaction walks through the regex-based redaction system that ships with the CLI. The intent is that redaction happens at capture time, not at query time, so the stored checkpoint is already safe to share.

FAQ

Q: Is Entire open source? A: The CLI is open source at launch. The context graph and the broader platform layer are not — those are the parts the company is building on top of the open-source foundation.

Q: Does Entire replace Git? A: No. Entire is a layer on top of Git. The checkpoint is attached to a commit SHA; the underlying repository is unchanged.

Q: How is this different from a Claude Code session log? A: Claude Code keeps transcripts in a local file under ~/.claude/. Entire attaches those transcripts to commits and makes them queryable by branch, shareable with reviewers, and addressable for restore. The difference is Git-addressability and team visibility, not the existence of the transcript itself.

Q: Does the CLI work offline? A: Yes for local commit-time capture. The web dashboard and cross-machine sync require connectivity, but the primitive works without it.

Q: What is the relationship to the “context graph” mentioned in the vision? A: The CLI is the write-path; the context graph is the read-path the company is building. Every checkpoint you write is a node the graph will query.

Q: Can I use Entire with agents that are not on the supported list? A: Yes, via the external agent plugin SDK. The docs.entire.io/agents/external-agent-plugins.md page defines the contract.

Q: What happens to checkpoints on a git rebase? A: Because checkpoints are stored as Git objects (notes/refs), they follow the rewritten commit SHAs. After a rebase, the checkpoint for the original SHA is orphaned but still in the object store; the new SHA carries the same checkpoint metadata.

Conclusion

Entire is a strong candidate for the platform layer that the AI-agent era of software development has been missing. The CLI is a small, sharp primitive that solves a real problem (agent context loss) without trying to be a Git replacement. The $60M seed and the investor list suggest the company has the runway to build the larger context-graph vision on top of a working open-source foundation. If you ship with Claude Code or Gemini CLI, the install is five minutes and the value shows up the first time you have to ask “why did the agent make this change three days ago?”

For a deeper look at how the CLI works under the hood, the Entire CLI: How It Works & Where It’s Headed post walks through the diff-to-checkpoint flow in detail.