Skip to main content

​
What is oobo?

Oobo is git for agents. It decorates git transparently and enriches every commit with the AI context that produced it. Humans type oobo commit (or alias git=oobo) and everything works like normal git. Agents use --agent for compact text output or --json for full structured JSON. Both get the same thing: every commit linked to the AI sessions, tokens, and code attribution behind it.

​
The problem

A git commit stores a diff and a message. That is all. It tells you what changed, but nothing about how it was written. Today, most code is written alongside AI conversations. You spend 14,000 tokens debugging a race condition in Claude Code, accept three Cursor completions, then run git commit. The commit captures the ten lines you changed. The conversation, the tokens, which lines the AI wrote vs. which you wrote by hand: gone. Close the tab, and that context disappears. Multiply that across a team of engineers, each using a different tool, and you have a codebase full of commits with no record of the AI work behind them.

​
Why decorate git?

Git is the one tool every developer and agent already runs. By decorating it, oobo captures AI context at the exact moment code enters the repository, without requiring plugins, editor extensions, or workflow changes. For agents, this is critical: agents commit code constantly, across tools, often in parallel. Oobo gives each commit a paper trail linking it back to the session, model, and tokens that produced it.

​
How it works

You run:  oobo commit -m "fix auth middleware"

  1. Execute real git commit
  2. Detect that this is a write operation
  3. Read active AI sessions from local tool storage
  4. Build an anchor: commit + sessions + tokens + attribution
  5. Write anchor to local DB + git orphan branch
  6. POST anchor to remote (if configured) → /anchors/ingest
  7. Return git's original exit code
Read operations (status, log, diff) pass straight through to git with zero overhead. Only write operations (commit, push, merge, rebase) trigger context capture.

​
The anchor

An anchor is oobo’s core primitive. It extends a git commit with AI context: 
Git commit  =  diff + message + author + timestamp
Anchor      =  commit + sessions + tokens + attribution
Each anchor records:
  • Which AI sessions contributed to the commit
  • Token counts (input, output, cache)
  • Code attribution (which lines came from AI, which from the developer)
  • Model used
  • Session duration
  • Author type: agent, assisted, human, or automated
Anchors live in a local SQLite database and on a git orphan branch (oobo/anchors/v1) that travels with the repo. The orphan branch is always created on the first intercepted commit, so when a teammate clones, they get the full AI context history.

​
Output modes

Every command supports --agent (compact text, minimal tokens) and --json (full JSON). Both are global flags, mutually exclusive, and work on any command. Prefer --agent; use --json when you need the full object graph. 
oobo sessions --agent            # compact session list
oobo sessions show <id> --json   # full conversation as JSON
oobo stats --agent               # compact stats
Agents discover oobo through a skill file at ~/.oobo/skills/oobo/SKILL.md, with symlinks in ~/.agents/, ~/.claude/, ~/.cursor/, ~/.codex/, and ~/.gemini/ skill directories. See AI Agent Integration for details.

​
Installation

For humans: 
curl -fsSL https://oobo.ai/install.sh | bash
For agents (silent install, JSON output): 
curl -fsSL https://oobo.ai/install.sh | bash -s -- --agent
# Returns: {"status":"ok","version":"...","binary":"...","platform":"..."}
Agents that read the SKILL.md will find the install command in the frontmatter: 
install:
  check: command -v oobo
  run: curl -fsSL https://oobo.ai/install.sh | bash -s -- --agent
See Installation for platform details, Docker, and building from source.

​
Key capabilities

  • Transparent git decorator: use oobo exactly like git, or alias git=oobo
  • Agent-native: every command supports --agent (compact) and --json (full JSON); ships with a SKILL.md agents can read
  • 10 AI tool integrations: Cursor, Claude Code, Gemini CLI, Codex CLI, OpenCode, Copilot, Windsurf, Aider, Zed, Trae
  • Local-first: all data stays in ~/.oobo/db/oobo.db unless you explicitly push or share
  • Privacy by design: read-only access to tool data, secret redaction, no telemetry sent without opt-in

​
Architecture

Oobo operates in two layers: Layer 1: Git Decorator. Decorates git to intercept write operations (commit, push, merge, rebase), enrich them with anchor metadata (linked sessions, agent/human attribution, diff stats), and sync metadata via the oobo/anchors/v1 orphan branch. Layer 2: Local Memory Engine. Maintains a local SQLite database with session history, token counts, analytics, and time-series data across all AI tools. This powers commands like oobo sessions, oobo stats, and oobo card.