Learn · Article 4 of 4
The Version Control Layer for Agentic Software
For investors and strategic readers.
The infrastructure of software development was designed for human authors who change one thing at a time. Git, code review, CI, observability — every layer assumes a small number of mostly-independent changes per unit time, each carrying intent that a reviewer can read. The cadence and shape of human commits is the load-bearing assumption underneath the whole stack.
That assumption is being eroded faster than most of the surrounding tooling acknowledges. Agents are now writing meaningful percentages of production code at many companies. They are also operating in production directly, taking actions through tools, updating memory across requests, and reasoning over schemas that change underneath them. The shape of an agent change is not the shape of a human change. It is wider, more entangled, and harder to interpret as intent.
The economically interesting consequence isn’t that AI authors more lines of code. It’s that the substrate beneath agent platforms has not yet been built. There is no equivalent of Git for the artifact that is being changed. There is no equivalent of diff for the dimensions in which agents change behavior. There is no equivalent of rollback that restores the system to a coherent prior state. The platforms running agents — LangGraph, Claude Agent SDK, the long tail behind them — are converging on similar primitives because they all need this layer, and it doesn’t exist.
git.agentic is a bet that this missing substrate is the durable place to build. The technical core is straightforward to describe: every commit is a content-addressed snapshot of the full tuple that determines agent behavior — code, prompts, tool fingerprints, model identifiers, memory segments, schema version — and rollback restores all of it atomically. Git is the storage substrate; an extended Commit object is the API contract the rest of the world integrates against. The MVP and public repository launched on May 22, 2026; production validation is in progress.
The market positioning is where the bet sharpens. The product is not pitched at end users building their own agent loops. It’s pitched laterally, at the platforms themselves. The first non-LangGraph integration is the Claude Agent SDK, framed explicitly as a partner integration rather than a competitive feature. The reason is simple: the layer underneath agent platforms is a different category of business than another agent platform. The platforms compete with each other on developer experience and on the integrations they ship. They are not in a hurry to compete on storage substrates. The substrate is where standardization is most likely and where the moat is structural rather than UX-driven.
Two consequences follow from this positioning. The first is that the surface area of the contract is the most important thing the project ships. The Commit object’s schema, the SDK’s public types, and what the SDK deliberately doesn’t expose — Git refs, object-store paths, internal segment IDs — determine whether platforms can adopt without locking themselves to internal implementation details. Those decisions are being made now. The second is that the demo discipline is unusually strict for an early-stage project. A single named demo — the broken-prompt demo — has veto power over every v1.0 feature. The discipline exists because the alternative path, building broadly across personas, would burn the project’s runway before any platform has anything specific to integrate against.
The timing question is the one most worth pressure-testing. The agent platforms are coalescing right now. The API contracts being defined in the next twelve to eighteen months will lock in for years; the platforms that win will end up shipping the abstractions that everyone else integrates against. The window to be the version-control substrate underneath that layer is open, and probably narrow. If you believe most software in 2030 will be written and operated by agents, you should also believe the infrastructure underneath it will not look like the infrastructure of 2020. Something has to be the durable artifact that ties together what the agent did across the six dimensions that matter. That artifact does not exist today.
git.agentic is one bet on what it could be. The technical part is the easier half. The harder half is the API contract — and whether the platforms that need this layer recognize it as the place to integrate, in time.