Beyond Git

Git was built for one human, one machine, one source tree.

That model held long enough to feel permanent.

Even as teams distributed, the geometry stayed the same.

Humans edited files. Commits captured intent. Pull requests coordinated work. CI confirmed the result.

A repository was where humans changed code.

That assumption is breaking.

A modern repository is no longer operated by humans alone.

It now contains Claude Code sessions, Codex loops, Hermes runtimes, MCP tools, cron jobs, webhooks, validators, remote workers, background agents, parallel worktrees, and humans somewhere in the mix.

Not sequentially. Simultaneously.

The repository is no longer a place. It is a process.

Git models state.

It knows what changed, who committed, and when.

It does not know which agent initiated the change. It does not know which prompt produced it. It does not know what reasoning preceded it. It does not know what tools participated. It does not know what context existed between commits. It does not know whether the action was autonomous, scheduled, or supervised.

Git sees diffs. Git does not see decisions.

The old model: a repository is where software lives. The new model: a repository is where intelligence operates.

The distinction sounds abstract.

Then several systems touch the same repository at once.

One agent refactors an API. Another reviews security boundaries. A scheduled loop generates tests. A webhook updates schemas. A remote worker validates a deploy. A human reviews architecture. Worktrees isolate concurrent tasks. Background systems reopen work that failed.

Git stores the result. Git cannot describe the operation.

Two layers begin to matter.

Not replacements for Git. Additional dimensions.

The first is spatial.

A branch is logical. A worktree is operational.

Worktrees let multiple active realities of the same repository exist at the same time. Isolated contexts. Isolated tasks. Isolated execution surfaces.

In a human-only world, isolation was a convenience. In a multi-agent world, isolation is a requirement.

Without it, concurrent intelligence is destructive.

The second is temporal.

Worktrees give you space. They do not give you continuity.

For continuity, you need memory.

Not conversational memory. Operational memory.

A record of who acted, what they did, which tools participated, what evidence remained, and which commitments are still open.

This is what a ledger does.

A ledger is not source control. A ledger is operational history.

Git answers: what changed? A ledger answers: what intelligence operated here, under what conditions, and with what outcome?

The distinction sounds small. It is not.

Modern repositories are increasingly composed of activity that happens between commits.

Loops. Hooks. Validators. Retries. Reviews. External triggers. Scheduled executions. Remote orchestration.

Without an operational substrate, these events are invisible.

The repository develops blind spots.

Blind spots become dangerous the moment systems operate without supervision.

At that point, the repository stops being a passive container.

It becomes shared infrastructure between humans, agents, automation, and orchestration.

A distributed cognitive workspace.

This is why append-only operational ledgers matter.

Not because they are sophisticated. Because they are simple.

An append-only ledger creates continuity that outlives any single agent session.

Every operation recorded. Nothing edited. Nothing deleted.

State computed by replaying history, never stored.

Combine Git with worktrees, ledgers, agents, validators, hooks, and remote execution.

The repository becomes something new.

Not source control. A coordination substrate for collaborative intelligence.

Git modeled the history of software.

The next layer models the history of intelligence operating on software.

That is the layer we are building.

The Mentu Protocol is one implementation of this layer. Append-only signals. Mechanical trust. Open source.