Git was for humans.
We need something else.

The filesystem is a terrible primitive for agentic code

Think about what Git actually assumes. One person. One machine. One local copy of the codebase. You work on it, you push it, someone reviews it. That was elegant when the bottleneck was how fast a human could think and type.

Now picture 50 agents modifying the same codebase at the same time. You don't get "merge conflicts." You get chaos. Branch-per-agent gives you thousands of divergent realities. Filesystem locks are too blunt. And PR review? That's the single-threaded bottleneck choking a massively parallel system. Your fastest engineer is now your slowest reviewer.

Here's the thing most people haven't internalized yet: code is no longer something humans carefully craft and contemplate. Code is high-velocity data. It should be stored, synchronized, and validated like data, with write atomicity, real-time subscriptions, conflict resolution, and continuous validation baked into the storage layer. Not bolted on through CI pipelines that run 20 minutes after the fact.

Store code in a database, not a filesystem

This is the core idea. Treat the codebase as a live, transactional, event-sourced data system. Not a tree of files that get synchronized through patches and diffs.

Every write is a transaction. An agent acquires a fine-grained lock at the function level or the block level, not the whole file, makes its change, and it's immediately visible to every other agent. No more "push and pray." No more rebasing a 78-commit branch against a target that moved while you were working.

Every mutation is replayable. This is the part that matters most. Humans couldn't externalize their thought process while coding. They just... wrote code and left a commit message. Agents can capture everything: the reasoning, the alternatives they considered, the context they consumed, the confidence level. Your version history stops being a flat diff log and becomes a complete decision graph. That was never possible before.

Review happens continuously, not at a gate. Real-time validation (lint, format, type-check, test, security scan) runs on every single transaction. Not in some CI pipeline that fires 20 minutes later. Review shifts from "human sitting in the critical path" to "continuous automated attestation with human oversight on the things that actually matter."

Concepts that don't survive the transition

The Branch. Branching exists because workers are disconnected from each other. When all agents operate against a shared transactional store, you don't need branches for daily work. You might still branch for experimentation, like trying a radically different approach in isolation, but it stops being the default mode for getting anything done.

The Pull Request. A PR is basically a batch review of accumulated work. When every mutation gets validated in real-time and the full reasoning chain is captured alongside it, the whole "request permission to merge" ceremony becomes unnecessary. Humans set the policies. The system enforces them. Done.

The Merge Conflict. Conflicts exist because of disconnected state. Period. A transactional system with fine-grained locking and CRDTs resolves conflicts at write-time. Two agents editing the same function negotiate in real-time instead of discovering the problem three days later through a three-way diff.

The Local Checkout. There is no "local." The codebase is a shared distributed store. Agents read and write directly. Humans interact through views (IDE integrations, dashboards, policy consoles) that project the live state. The mental model shifts from "I have my copy" to "I have my view."