Open source · Rust + Tauri · under 100MB

The system of record
for how teams build with

Run your coding agents — replay any session, review as a team, and trace every line back to the decision behind it.

Download for free Book a demo

Watch the short product demo →

Runs and records every agent your team uses

ORG-2
Claude Code
Codex
Cursor
Copilot
Antigravity
Kiro
OpenCode
Amp
Aider
Goose
Cline
Devin
Grok
Qwen Code
Kimi Code
Mistral Vibe
Droid
Continue
Kilo Code
Hermes
OpenClaw
Codebuff
Mimo Code
Autohand
OMP
Pi

Answering why a piece of code exists — and whether it worked — has always meant stitching systems together by hand.

Jira

sees only tickets

Codex

sees only its own sessions

GitHub

sees only committed lines

Amplitude

sees only metrics

Nothing connects them. That was survivable when humans wrote the code. At agent speed it isn't: code written on Monday is legacy by Friday.

Fragments, not a record — and no way to improve. Traceability tools have always died of manual upkeep. Ours writes itself.

The score

Agents write the parts. ORG-2 preserves the score.

Five agents, a human, and a test suite all played at once. Every tool hears only its own part. The record underneath is the only place the performance exists in full — on one clock, in one key, replayable.

One clock

Six sources, one timeline. Sessions from every agent land on the same axis, so the order things actually happened in survives.

The threads are the product

A handoff between two tools is exactly what neither tool records. The record underneath is the only place it exists.

A score gets played back

Scrub any session at 1x to 6x, or hand the whole performance to someone who wasn't in the room.

The chain

Git blame stops at who. ORG-2 accounts for the how, the why, and the outcome.

01
who
Git blame
The name on the commit. Where every existing tool stops.
02
how
The trajectory
Every message, tool call, file edit, and command — replayable like a video.
03
why
Intent & goal
What the human asked for, what the agent understood, and the goal it served.
04
whether
Delivered outcome
An evidence graph tying each piece of shipped work to its proof.

One graph, from intent to impact, across every coding agent — including work that never touched the app.

What you get

A workspace that runs your agents — and a record that writes itself.

Built-in Rust harness

Run fast, token-saving, customizable native agents on your existing API keys and agent subscriptions. No margin, no lock-in.

Sessions across 20+ apps & CLIs

Load and manage agent sessions from every tool in one place. Scan history, inspect subagents, control each source without switching apps.

Tool calls, now as videos

Replay work from the native harness and 15+ CLI agents. Messages, tool calls, file edits, and command output stay synchronized on one timeline.

Review trajectories, not just PRs

Share sessions across devices and teammates. Review the full agent trajectory rather than the resulting diff, and comment in context.

AI blame, not just Git blame

Don't stop at who changed a line. Trace it back to the agent sessions, tool calls, and decisions that drove the change.

Drift detection

The record holds what was asked, what the agent understood, and what it did — so hooks flag malpractice the moment execution drifts from intent.

Evidence graph

Every piece of delivered work is tied to its proof, so you can show what shipped and what it was for.

Full dev workspace

Terminal, source control, Git history, and pull-request review without leaving your agent workspace.

Design Mode

Inspect live pages in the native WebKit browser. Select an element and send its exact page context straight to the agent.

Supported agents

Every agent your team already uses — neutral by design.

Launch them from ORG-2, or let ORG-2 ingest what you ran elsewhere and backfill from each tool's own history. An agent vendor can never be the neutral record across its competitors.