How Origin completes RhodeCode

If you run RhodeCode, you’ve already made a decision most teams haven’t: your source code belongs inside your own infrastructure. Behind your firewall, under your access controls, on your terms. You didn’t outsource the system of record for your most valuable asset, and you’re not about to.
But something changed underneath that decision. A growing share of the code landing in your repositories wasn’t written by the person who committed it. It was written by an AI agent — Claude, Copilot, Cursor, Codex, Gemini — and accepted by a developer who moved on to the next task. The commit says a human authored it. The reality is more complicated, and your tooling can’t see the difference.
That’s the gap Origin fills. And it’s why we think the two belong in the same stack.

The premise you already bought into

Self-hosting source control is a statement about control and accountability. You want to know who can reach what, who changed what, and to be able to prove it — for security, for compliance, for the simple engineering discipline of understanding your own codebase. RhodeCode gives you that for the repository: unified access control across Git, Mercurial, and Subversion, code review, and a full audit trail, all running where you decide.
AI coding tools quietly broke half of that promise. Not the access control — the accountability. When an agent writes a function, git blame still points at whoever hit commit. The prompt that actually produced the code, the model that ran, what it cost, whether anyone reviewed the reasoning — none of it is in your repository. The intent behind the code is gone the moment the session ends.

What Origin adds

Origin is a system of record for how AI produced your code, built to sit alongside the system of record for the code itself. It captures every AI coding session — across agents — and ties it back to the lines that shipped:

• Per-line attribution (AI Blame). For any line, see which agent and which prompt wrote it — not just who committed it. git blame tells you the courier; Origin tells you the author and the instruction.
• Prompt provenance (“Origin Why”). Point at a regression and get the session, the prompt, the reasoning, and the diff that introduced it. It’s git bisect for the prompt behind a bug — attribution as incident response, not a passive ledger.
• Governance and policy. Enforce rules on AI-generated changes and gate merges on review, right in your pull-request flow.
• Cost and usage visibility. Tokens, spend, and rework per agent, model, and repository — the numbers that justify (or question) the AI budget.
• Compliance evidence. A durable, exportable record of AI-versus-human authorship and what went into each prompt — the kind of proof auditors and licensing reviews increasingly ask for.

Crucially, Origin can run the same way RhodeCode does: self-hosted, on-premise, air-gapped. Every prompt, diff, and line of code stays inside your network. The attribution data doesn’t leave the building any more than your repositories do.

Better together

The two products answer two halves of the same question.

RhodeCode is the system of record for your source — who can touch it, who changed it, and the reviewed history of every change.

Origin is the system of record for how AI produced it — which agent, which prompt, what it cost, and whether a human validated the reasoning.

Put them together and the accountability story is whole again. A reviewer looking at a change in RhodeCode can ask not just what changed but why it was written this way and by which prompt. A security team can prove which code was AI-generated and what context the model was given. An engineering lead can see where the AI budget goes and where it produces rework. All of it behind your own firewall, under your own controls — the posture you already chose.

What it looks like in practice

A test goes red on a pull request. Instead of reverse-engineering intent from a diff, the reviewer traces the failing line to its origin: written by an agent three days ago, from the prompt “add multi-item discount to invoice totals,” which the agent itself flagged for a bounds check that never got verified. The fix is obvious once the intent is visible — and the whole trail lived inside the same infrastructure as the repository.

That’s the workflow AI coding was missing: not less automation, but accountability that keeps pace with it.

Try Origin

If you self-host because control and accountability matter, Origin extends both to the AI now writing a meaningful share of your code — without giving up either.

Learn more at getorigin.io, or read about the self-hosted and air-gapped deployment at getorigin.io/self-hosted.