oobo

Context beyond the diff.

Capture, search, and recall AI context across every commit.
Sessions, tokens, code attribution, semantic code search, and engineering memory via MCP.
15 AI coding tools supported. Local-first. Optional cloud for team recall.

Documentation · Report Bug · Request Feature · Contributing

curl -fsSL https://oobo.ai/install.sh | bash

Platforms: macOS (Apple Silicon, Intel) · Linux (x86_64, ARM64, glibc, musl)

Or grab a binary from Releases.

• Transparent Git Hooks -- Works alongside your normal git workflow. Post-commit hooks automatically capture AI context without changing how you work.
• AI Session Tracking -- Automatically discovers and links AI chat sessions to your commits -- which agent wrote what, how many tokens it took, and which conversation produced each change.
• Semantic Code Search -- Hybrid BM25 + vector search (powered by sonar) finds code by meaning, not just keywords. Indexes locally, no cloud needed.
• 15 Tools Supported -- Cursor, Claude Code, Gemini CLI, OpenCode, Codex, Aider, GitHub Copilot, Windsurf, Zed, Trae, Amp, Continue, Factory Droid, Junie, and Kiro.
• Code Attribution -- Know exactly which lines were AI-generated vs human-written, per commit.
• Engineering Memory via MCP -- Expose your team's engineering history to AI agents via Model Context Protocol. One command (oobo mcp install) configures Cursor, Claude Code, or Copilot. Agents gain access to recall, get_context, and ask tools -- retrieving relevant decisions, patterns, and context from past work.
• Agent-Native -- Three output modes (pretty / --agent token-efficient plain text / --json structured). --agent auto-activates when stdout isn't a TTY or inside a coding agent.
• Local-First, Private by Default -- Anchors live on a git orphan branch, with a lightweight local cache in ~/.oobo/. Anchor metadata travels only where your code already goes (your git remote, via git push), or to a separate private repo if configured. No telemetry. Secrets are redacted before sharing.
• Anchor System -- Extends git commits with structured AI metadata that travels with the repo via a git orphan branch. Configurable remote target for teams that want anchors separate from source.

# 1. Install -- setup runs automatically, detects your tools, configures everything
curl -fsSL https://oobo.ai/install.sh | bash

# 2. Use git normally -- hooks capture AI context on every commit
git commit -m "fix auth middleware"
git push origin main

# 3. See what happened
oobo                            # in-repo: scrollable feed of your anchors
oobo anchor show <sha>          # drill into one anchor (sessions, tokens, attribution)
oobo goto <turn-or-sha>         # time-travel to a turn or commit (auto-stashes)
oobo back                       # return to where you were
oobo blame src/main.rs          # git blame + per-line AI attribution
oobo search "auth middleware"   # semantic code search (hybrid BM25 + vector)
oobo recall "auth bug"          # search sessions + anchors

Optionally, add an oobo.ai API key for remote recall and MCP engineering memory:

oobo settings set key <your_key>

oobo mcp install              # auto-detect and configure Cursor/Claude/Copilot
oobo mcp install cursor       # configure a specific tool
oobo mcp install --hosted     # cloud-only (no local binary needed by the AI tool)

Once configured, your AI agent gains access to tools like recall (search engineering memory), get_context (token-budgeted relevant context), and ask (natural language queries against your team's history).

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

  1. Post-commit hook fires
  2. Hook calls `oobo hooks post-commit`
  3. Oobo reads AI sessions from local tool storage
  4. Builds anchor: commit + sessions + tokens + attribution
  5. Writes anchor to git orphan branch

Git operations work exactly as normal -- oobo captures context via hooks, not by wrapping git.

An anchor is oobo's core primitive -- it extends a git commit with AI context:

Git:     commit = diff(files)
Anchor:  anchor = commit + sessions + tokens + attribution

Each anchor records which AI sessions contributed, token counts, code attribution (AI vs human lines), model used, and session duration. Anchors live on a git orphan branch (oobo/anchors/v1) that travels with the repo -- no external dependencies.

All tools are read-only -- oobo never writes to AI tool data directories.

Oobo is built for agents. Agents commit code constantly, across tools, often in parallel. Without oobo, there is no record of which agent wrote what, how many tokens it took, or which conversation produced a given function.

curl -fsSL https://oobo.ai/install.sh | bash -s -- --agent
# → {"status":"ok","version":"...","binary":"...","platform":"..."}

The --agent flag suppresses colors and interactive prompts and returns a single JSON line.

Every command has three mutually exclusive output modes:

• Pretty (default) -- rich TTY output with color, alignment, and interactive TUIs where available.
• --agent -- token-efficient plain text, similar in spirit to git log --oneline. Auto-activates when stdout is not a TTY or one of CURSOR_AGENT, CLAUDECODE, AIDER, CONTINUE_SESSION, CONTINUE_IDE, AICOMMITS is set.
• --json -- full-fidelity structured JSON for scripts and programmatic use (jq-parseable).

oobo --agent                         # token-efficient commit feed
oobo --json                          # flat JSON array of anchors
oobo blame src/main.rs --json        # per-line AI attribution as JSON
oobo search "auth" --agent           # compact code search results
oobo recall "auth" --agent           # compact session search results

Oobo installs a skill file at ~/.oobo/skills/oobo/SKILL.md during oobo setup, with symlinks in ~/.agents/skills/oobo/, ~/.claude/skills/oobo/, ~/.codex/skills/oobo/, ~/.cursor/skills/oobo/, and ~/.gemini/skills/oobo/. AI coding tools discover the skill automatically and know how to install and use oobo.

For tools that support it (Cursor, Claude Code, Gemini CLI, OpenCode, Kiro, Continue, Factory Droid), oobo installs hooks that track agent activity in real time: session start/end, tool calls, subagent spawns, thinking events, and context compaction. This enables precise session linking and rich telemetry attached to every commit anchor.

oobo                             # in-repo + TTY: scrollable anchor-feed TUI
                                 # in-repo + --agent/--json: list anchors
                                 # outside a repo: first-run hint or short status
oobo -n 20 --since 7d           # filtered
oobo --tool cursor               # per-tool
oobo --project myapp             # outside a repo, aggregate one project

oobo anchor show <sha>           # drill-down: sessions, tokens, attribution
oobo anchor show <sha> --json    # structured JSON for scripts

oobo goto <turn-id-or-sha>              # travel to a turn or commit
oobo goto <id> --no-stash               # fail if worktree is dirty
oobo back                               # return to where you were

goto auto-stashes dirty changes, loads the target tree, and records a return point. Multiple goto calls stack -- each back pops one level, like a browser back button.

oobo blame src/main.rs                       # git blame with an extra AI column
oobo blame src/main.rs abc123                # at a specific commit
oobo blame src/main.rs --json                # per-line AI attribution as JSON

Every git blame flag (-L, -w, --porcelain, etc.) is forwarded; machine-output formats (--porcelain, --line-porcelain, --incremental) bypass the AI column automatically.

oobo search "auth middleware"                # hybrid BM25 + vector
oobo search "parse config" -k 10             # top 10 results
oobo search "deployment" --content docs      # search docs only
oobo search "auth" --mode bm25              # keyword only (fastest)

oobo recall "auth bug"                       # full-text search
oobo recall "auth" --since 7d --tool claude --project myapp
oobo recall "auth" --json                    # structured results

oobo delta                                   # compare HEAD to its previous anchor
oobo delta abc123 def789                     # explicit pair
oobo delta --full --json                     # include sessions, decisions, techniques

Requires an API key (oobo settings set key <...>).

oobo help                                    # list all topics
oobo help blame                              # reading the AI attribution overlay
oobo help hooks                              # git and agent hooks explained

oobo settings                                # list default-scope keys
oobo settings key                            # get the API key (default scope)
oobo settings set key sk_...                 # set API key (remote search)
oobo settings set api_url https://oobo.mycompany.com
oobo settings project set remote oobo        # push anchor branch to git remote "oobo"
oobo settings unset transparency             # remove a key

Scopes: default (implicit) or project. Verbs: get (default), set, unset.

oobo enable                                  # start tracking this repo
oobo disable                                 # stop tracking this repo

oobo setup                                   # interactive wizard: install hooks, discover tools, seed config
oobo setup --non-interactive                 # for scripts + first-run agents
oobo setup --reindex                         # forced full rescan
oobo setup --repair                          # fix broken symlinks / hooks
oobo update                                  # check for updates and self-update

Tool detection is automatic on every commit. No indexing step required.

Most config is now declarative via oobo settings:

oobo settings set key sk_...                         # API key for remote search
oobo settings set api_url https://oobo.mycompany.com  # self-hosted backend
oobo settings set transparency on                    # store redacted transcripts
oobo settings project set transparency off           # per-project override
oobo settings set setup.scan_roots "~/src,~/work"

Note: api_url sets the API server for remote search and delta. remote is project-scope only and controls which Git remote the anchor branch is pushed to (defaults to origin). To push anchors to a separate repo:

oobo settings project set remote git@github.com:org/repo-anchors.git

Anchor data is always written locally first. If the push fails, data is safe -- the next successful push includes all pending anchors.

For full fidelity or automation, ~/.oobo/config still works:

[server]
url = "https://api.oobo.ai"
api_key = "sk_..."

[privacy]
transparency = "off"   # off | on

[anchors]
remote = "origin"      # or a full URL for a separate anchor repo

[cursor]
enabled = true

[claude]
enabled = false

Full tool list: cursor, claude, gemini, windsurf, aider, copilot, zed, trae, codex, opencode, kiro, continue, droid, junie, amp.

By default, oobo points at api.oobo.ai -- our free hosted backend. Create a free account at oobo.ai, grab an API key, and run:

oobo settings set key <your_key>

That stores the key for authenticated API use (e.g. oobo recall --remote). Team sync is Git-first - anchors live on the orphan branch and push with your code. Run oobo settings unset key to clear the key.

To run your own server:

oobo settings set api_url https://oobo.mycompany.com

Your backend implements endpoints under /anchors:

git clone https://github.com/ooboai/oobo.git && cd oobo
cargo build --release
# binary at target/release/oobo

• Read-only -- never writes to AI tool directories
• Local by default -- anchors live on a git orphan branch in your repo, config in ~/.oobo/. Metadata is pushed alongside your code to your existing git remote; the optional search/delta API requires a separate key
• Secret redaction -- sessions are scrubbed with gitleaks patterns before sharing
• No telemetry -- oobo does not phone home
• Config protection -- API keys in config get chmod 0600

See SECURITY.md for the full policy.

Oobo is open source under Apache 2.0 and MIT (dual licensed, at your option). See CONTRIBUTING.md for development setup, project structure, and guidelines.

Dual licensed under Apache 2.0 and MIT, at your option.