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 the --agent flag on any command to get 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. Fire event to remote endpoint (if configured)
  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.

​
The —agent flag

Every oobo command supports --agent for structured JSON output. This is the single entry point for machine-readable output, and it works on every command: 
oobo sessions --agent            # sessions as JSON
oobo projects --agent            # projects as JSON
oobo anchors --agent             # enriched commits as JSON
oobo stats --agent               # analytics as JSON
oobo sources --agent             # data source coverage as JSON
oobo dash --agent                # config overview as JSON
oobo version --agent             # version info as JSON
oobo inspect --agent             # diagnostics as JSON
oobo card --agent                # developer card as JSON
--agent is a global flag. Put it anywhere: oobo sessions list --agent, oobo stats --tool cursor --agent, oobo sessions show abc12 --agent. It always forces JSON output. Agents discover oobo through a skill file installed at ~/.agents/skills/oobo/SKILL.md. The skill file lists every command, JSON field, and configuration option so agents can invoke oobo without guessing. See AI Agent Integration for the full agent workflow.

​
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 for structured 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.