Creation History, Not Just Code History
AI agents are making code review harder in a strange way: they leave behind more code and less of the history that explains it.
A developer receives a clean multi-file diff, passing tests, and a confident summary. What disappears is the work that produced it: the prompt, the intent, the failed attempts, the decision to accept. Git answers "what changed?" exceptionally well. It does not preserve the structured agent process that produced the change.
Libra is an open, local-first, AI-native version control system. Its defining capability is a Git-compatible record layer for agentic coding: it captures the history that otherwise disappears — how the software was made — and keeps it in the repository, beside the code, as something you own rather than a service you rent. Libra works with existing Git workflows and remotes rather than asking developers to abandon them.
The diff is no longer the whole story.
The Diff Is Becoming Too Small
For decades, version control recorded one thing well: the state of source code over time. That model fit an era when humans were the primary authors. A developer edits files, writes a commit message, opens a pull request, and asks other humans to review the diff. The commit is the artifact; the diff is the object of review.
Agentic coding breaks that assumption. When an agent implements a feature or fixes a bug, the final diff is only the last visible surface of a much larger process. Before it exists, a prompt was written, an intent was inferred, that intent was discussed or corrected, files were read, a plan was chosen, tools were called, tests failed and were retried, and candidate patches were accepted or thrown away. A reviewer who sees only the diff cannot answer the questions that matter most: what was asked, what the agent understood, what it tried, what failed, and who accepted the result.
Git is intentionally lossy at this layer — it compresses the work into a snapshot and a message. That was a feature when humans carried much of the missing context in their heads. With agents, the missing context is machine-generated, high-volume, and usually never seen by the reviewer. By the time a commit appears, much of the evidence needed to understand the work has already disappeared into a closed chat window or a vendor log.
Agent-generated code needs more than code history. It needs creation history.
Git keeps code history. Libra adds creation history.
The Record Layer
Libra is built around one principle: the record of how software was made should live with the software itself.
Libra includes an agent workspace, but its purpose is not to become one more closed coding assistant. Nor is it an observability dashboard: those systems track model calls, token usage, and application behavior outside the repository, disconnected from the working tree and the review. Libra's defining layer is the repository record itself. Most coding agents already produce some form of session transcript or event log, but those records are usually flat, vendor-shaped, and cut off from the code. Libra normalizes the work into typed, durable records stored inside the repository, beside its code history, and tied to the commits and files they explain:
| Record | What it answers | | --- | --- | | Ask — what was wanted | | | Prompt | What did the user originally ask? | | Intent | What did the model infer from the prompt? | | Intent Discussion | How was that intent reviewed, corrected, or confirmed? | | Plan | How did it intend to do the work? | | Act — what the agent did | | | Run | What execution attempt happened? | | Tool Invocation | What did it read, run, inspect, or modify? | | PatchSet | Which candidate changes were produced? | | Accept — how the result was judged | | | Validation | What passed or failed? | | Evidence | What output supports the result? | | Risk Signal | What should a reviewer pay attention to? | | Decision | Who, or what policy, accepted the change? |
The taxonomy is versioned to grow as agents do, and it separates what the model claims — its inferred intent — from what actually happened: its tool calls and validation results.
Take a simple task: fix a failing test without changing the public API. The agent plans it, applies a patch that fails, revises, and lands one that passes — and with Libra a reviewer can follow every step, not just the final diff. A commit tells you where the code ended up. Libra shows you the flight path. Nobody reads a flight path end to end, and nobody should have to: risk signals surface the runs worth a look, and the rest of the record waits quietly until a line breaks six months from now and someone asks why it exists.
For an open-source maintainer or independent developer already using Codex, the shortest path is to import an existing Git repository into Libra, enable capture, and keep working with the same agent:
# Import an existing local Git repository into a new Libra working directory.
libra init --from-git-repository /path/to/project /path/to/project-libra
cd /path/to/project-libra
# Install the Codex capture hooks once.
libra agent add codex
# Use Codex normally, then inspect what Libra captured.
libra agent session list
libra agent checkpoint list
libra agent checkpoint show <checkpoint-id>
The coding workflow stays familiar. Libra adds the durable session and checkpoint record: what the agent was asked to do, what it changed, and the trace that can later explain the resulting code. Capture can be disabled at any time without deleting the history already recorded.
What We're Building Today — and Where It's Going
This is early, and we want to be precise about the line between what works now and what we are reaching for.
Today, Libra captures agent work into the repository in two ways. First, you can run the agent through Libra itself — in its web workspace, or over the Model Context Protocol — so the record is captured as a byproduct of execution, not reconstructed afterward. Second, you can keep the tools you already use: Libra installs capture hooks for external coding agents including Claude Code, Codex, and OpenCode. Its capture path fails closed, caps transcript and stderr output, redacts sensitive fields before anything is stored, and requires explicit authorization for raw export. Both paths land the history on disk in an open format — local-first, and MIT-licensed like the rest of Libra.
The vision reaches further than today's implementation. We are working toward line-level attribution that maps a source line back to the session and decision that produced it, search across a repository's creation history, review surfaces built for teams rather than for a single developer, and — further out — our own hosting built for agent-scale monorepos. Some of this is already visible in the architecture; some is still ahead. Naming what is not yet built is part of keeping the record honest.
Open, Local-First, and Owned by the Repository
Creation history is sensitive. It holds prompts, design tradeoffs, failed attempts, security assumptions, model outputs, and human decisions. As agent-generated code enters production, that process becomes part of the software supply chain — evidence that should not be locked to a single vendor.
So the record layer should be open, and it should be yours. Libra is open source because a record you cannot inspect is a record you cannot trust. And because the format is plain, documented data, the history stays readable even without Libra. It is local-first because prompts and decision history do not belong on someone else's server by default. Libra does not upload the creation-history record unless you choose to share or push it. Model requests still follow the data policy of the provider you choose; with a local or private model, the full workflow can remain under your control. Capture is opt-in, and redaction reduces exposure without pretending that arbitrary source code, command output, or model text can always be classified perfectly.
Ownership also includes retention control. An independent developer can prune local records; a project that needs stronger audit guarantees can define a retention policy for accepted or published records. Creation history can serve as supply-chain evidence only when the policy around that evidence is explicit.
Monorepo support is part of Libra's longer-term product strategy, not something the record layer requires today. We believe fleets of agents working continuously will push more organizations toward large repositories and trunk-based development, placing new demands on clones, large-object storage, and concurrent version-control operations. Libra is being designed toward that future, including open-source, self-hostable hosting for agent-scale monorepos. That future product will be opt-in, not lock-in: creation history stays independent of any single host, works with the remotes developers use today, and outlives any one agent, model, or vendor.
Toward Creation History
As agents grow more capable, they will not just autocomplete functions. They will implement features, migrate APIs, refactor modules, analyze failures, and coordinate with one another. When that happens, a repository that stores only final file states is no longer enough. It has to preserve the structured process that produced them.
None of this replaces human judgment; it gives that judgment better evidence. Developers should not have to review every token an agent produced — but they should be able to review the prompt, the intent, the plan, the evidence, and the decision, and to ask not only "does this diff look right?" but "was this change made in a way we can understand, audit, and — where the environment allows — replay?"
That is the direction we are building toward: from diffs to provenance, from isolated agent sessions to portable engineering records, from opaque automation to inspectable process. The next generation of version control will not only preserve source code. It will preserve the process that created it.
Libra is MIT-licensed and available today at libra.tools; the code is at github.com/libra-tools/libra. If you maintain an open-source project or build independently with Claude Code, Codex, or OpenCode, install Libra, enable agent capture, and inspect your first creation-history record beside your code. If you believe version control should remember how software is made, come build it with us.
Git remembers what changed. Libra also remembers how — and that memory is yours.