OxigitWe Built a New Git for the AI Era

Every team that builds with coding agents has the same haunted repository.

The code works. The commits are there. But why they are there — which prompt produced them, which model wrote them, which session they belong to — evaporated the moment the terminal closed.

git log shows you an unexplained sequence of diffs. The actual engineering — the prompts, the reasoning, the session — is gone.

We got tired of it. So we did the unreasonable thing:

we built our own Git.

Meet Oxigit — an AI-native Git platform, written from scratch in Rust.

GitHub records what was pushed. Oxigit records how the AI got there.

The forge race has started

We are not alone in this diagnosis — and that is the best possible sign.

Cursor is building Origin, which they call "a git forge for the agentic era." Their framing is exactly right: code is moving faster than any infrastructure was built to handle. GitHub was designed for humans typing; now agents produce more code per afternoon than teams used to ship in a sprint, and the platform underneath has nothing to say about it.

Same diagnosis — our own answer. Oxigit is our take on the agentic-era forge:

self-hosted, open to inspect, written in Rust — and your code never leaves your server.

The forge of the AI era is too important a layer to rent.

Still Git. Just with memory.

The most important design decision: Oxigit is still Git.

Repositories stay standard Git repos. Existing clients connect over HTTPS or SSH. Nothing about your workflow breaks. What changes is what the platform remembers:

prompt → context recorded → commit → push → timeline, risk scan, score → recipe → replay

Hooks for Claude Code, Codex CLI and Gemini CLI install right from repository settings. From then on every commit knows its tool, model, original prompt and session. Instead of an anonymous commit list you get a prompt-by-prompt timeline of how the feature actually came to be.

Sessions are the real unit of work

When an agent builds a feature, the meaningful unit is not a commit. It is the session — the whole conversation that produced twelve commits across nine files.

In Oxigit a session is a first-class object: its prompts, its commits, its aggregate diff, its risk flags — on one page. A reviewer can inspect the whole change, drill into a single prompt, or revert the entire session as one unit.

Rolling back an AI's bad afternoon stops being archaeology and becomes one button.

Review that doesn't trust vibes

Every session gets reviewed twice: a deterministic scanner flags security, breaking-change and performance risks with no external calls — and an optional LLM writes a plain-language summary of what actually changed.

On top sits the Vibe Score — 0 to 100, A to F, derived from commits per prompt, risk density, churn, and whether the session got reverted. A review signal, not a substitute for judgement.

And where review isn't enough, guardrails act at push time: per-category rules that warn or outright block risky pushes before they land.

Recipes: sessions you can replay

Our favorite part, because it closes the loop.

A successful AI session can be published as a Recipe — a versioned, reusable change with its prompts, steps and diffs. Replaying one never touches your branch directly: Oxigit applies it in an isolated branch and opens a pull request for review.

That turns AI work into something rare: institutional memory. The great session that scaffolded your last service isn't a lucky transcript in someone's terminal history — it's an asset the whole team can rerun.

Why this matters

The industry keeps arguing about whether AI writes good code. The real operational problem is quieter: AI writes unaccountable code.

Prompts vanish. Sessions fragment. Review happens on diffs stripped of their intent. Every team using agents at scale feels this — and the fix belongs in the platform where the code already lives, not in another dashboard bolted on the side.

That is the bet behind Origin. It is the bet behind Oxigit.

Version control for the how, not just the what.

Commits tell you nothing. Sessions tell you everything.