Oobo

What Is Oobo?

Oobo is an open-source git decorator that captures AI coding context alongside every commit . It wraps git transparently — read operations pass through with zero overhead, while write operations (commit, push, merge) get enriched with metadata called an "anchor" that records which AI sessions contributed, token counts, model names, session duration, and per-file code attribution (human vs. AI lines).

The pitch: git tells you what changed. Oobo tells you how and why it changed — which AI conversation led to the code, what it cost, and who (or what) actually wrote each line.

Built in Rust by Teodos Pejoski, operated by NoCode, Inc. (Techstars-backed), launched March 2026 .

How It Works

Install oobo, run oobo alias install to alias git=oobo, then use git normally. Under the hood:

1. Read operations (status, log, diff) pass straight through to git — zero overhead
2. Write operations (commit, push, merge) trigger anchor creation:
   • Execute the real git command
   • Read AI session data from local tool storage (Cursor, Claude Code, etc.)
   • Build an anchor: commit hash + linked sessions + tokens + attribution
   • Write anchor to local SQLite + a git orphan branch (oobo/anchors/v1)
   • Optionally POST to a remote endpoint

The orphan branch is clever — anchor metadata travels with the repo when cloned or pushed, without polluting the main branch history.

The Anchor Model

An anchor extends a git commit:

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

Each anchor records:

• Linked AI sessions — which conversations contributed to this commit
• Token usage — input/output tokens, model used, cost estimates
• Code attribution — human vs. AI lines per file, down to line ranges
• Session metadata — duration, tool used, thinking traces

This creates two complementary records: git as the code ledger, oobo as the work ledger.

Tool Integrations

Oobo reads session data from 10 AI coding tools :

Tool	Sessions	Transcripts	Token Stats	Lifecycle Hooks
Cursor	✅	✅	✅	✅
Claude Code	✅	✅	✅	✅
Gemini CLI	✅	✅	✅	✅
OpenCode	✅	✅	✅	✅
Codex CLI	✅	✅	✅	—
Aider	✅	✅	✅	—
GitHub Copilot Chat	✅	✅	✅	—
Windsurf	✅	✅	✅	—
Zed	✅	✅	✅	—
Trae	✅	✅	✅	—

All access is read-only. Oobo never writes to AI tool directories.

Privacy and Security

The privacy posture is strong and well-documented:

• Local-first — all data in ~/.oobo/, nothing leaves the machine unless configured
• Read-only — never writes to AI tool directories
• No telemetry — zero phone-home behavior
• Secret redaction — sessions scrubbed with gitleaks patterns before any sharing
• No credentials accessed — only reads timestamps, model names, and token counts
• Offline by default — sync/ingest only with explicit configuration

Pricing

The CLI is free and open source (Apache 2.0 / MIT dual-licensed). The hosted platform at oobo.ai charges per "Processing Credit" :

Plan	Price	Credits/mo	~Commits/mo
Pro	$20/member/mo	300	~150
Pro+	$60/member/mo	1,000	~500
Business	$200/member/mo	5,000	~2,500
On-Demand	$0.10/credit	Unlimited	Metered
Enterprise	Custom	Custom	Custom

1 human commit = 2 credits. Bot commits (CI, dependabot) are always free. 14-day free trial, no credit card. All plans include all features — no feature gating between tiers.

Technical Assessment

Strengths:

• The anchor model is genuinely novel. Enriching git commits at write time captures ground-truth AI context that no post-hoc analysis can reconstruct. Platforms that analyze diffs after the fact are guessing; oobo was there when it happened
• Git orphan branch for metadata distribution is elegant — anchors travel with the repo without workflow changes
• Agent-native design. Every command supports --agent for JSON output. The install script returns structured JSON. Even the website serves markdown when fetched programmatically. This is built for AI-to-AI workflows
• Privacy model is unusually strong for a dev analytics tool. Local-first, no telemetry, read-only, secret redaction — all the right decisions
• Rust + SQLite — fast, no runtime dependencies, single binary
• Broad tool coverage — 10 integrations across the major AI coding tools

Weaknesses:

• 34 GitHub stars, 1 contributor — solo project risk. The Techstars backing helps, but the codebase depends on one person
• Requires developer adoption. Each developer needs to install oobo locally. This is a hard sell at enterprise scale vs. platforms that just connect to GitHub
• Attribution accuracy is unverified. How accurately can oobo determine which lines were AI-generated vs. human-written? The methodology isn't documented publicly
• The hosted platform is the real product — the open-source CLI is the distribution mechanism. The pricing suggests this is where value (and lock-in) lives
• No GitHub/GitLab native integration. Requires local installation, unlike platforms that operate at the repo or org level
• Brand new — created March 9, 2026, less than a month old at time of writing

Who's Behind It

Teodos Pejoski (GitHub: teodos) , operating as NoCode, Inc., Techstars-backed. The LinkedIn profile shows deep engineering background. 89 commits in under a month with disciplined commit messages and CI practices. The company name "NoCode, Inc." predates oobo — suggests a pivot or new product line.

Competitive Positioning

Oobo occupies a unique spot: it's a capture tool (data collection at commit time) trying to become an analytics platform (Semantic Timeline, Alignment, Risk/Health, Clarity Reports). The competitors differ by approach:

	Oobo	GitClear	Exceeds AI	Swarmia
Data source	Local capture at commit time	Git history analysis	PR/commit diff analysis	Git + Jira + surveys
AI attribution	Ground-truth (session linking)	Heuristic (code patterns)	Pattern analysis + commit parsing	None
Deployment	Local CLI per developer	SaaS (connect repo)	SaaS (GitHub app)	SaaS (GitHub app)
Open source	✅ Apache 2.0/MIT	❌	❌	❌
Price	Free CLI + $20-200/member/mo hosted	~$9-30/dev/mo	Custom	Custom
Maturity	1 month old	Years (established)	Months	Years (established)

The fundamental tension: oobo has better data (ground-truth session context) but harder deployment (every developer must install it). The SaaS platforms have worse data (inferring from diffs) but easier deployment (just connect your GitHub org).

The Tembo Angle

The agent-native design philosophy is directly relevant. Oobo treats AI agents as first-class citizens in the development workflow — not afterthoughts to be tracked, but participants whose contributions deserve the same attribution as human developers. The anchor model (structured metadata attached to every commit) could inform how Tembo tracks agent contributions across orchestrated coding sessions.

The bigger insight: as AI agents write more code, the question "who wrote this and why?" becomes critical for audit, compliance, and trust. Oobo is betting early that this metadata layer is a product category.

Bottom Line

Recommended for: Teams that want ground-truth AI attribution in their git history. Early adopters comfortable installing a CLI tool per developer. Engineering leaders preparing for a future where AI authorship tracking is required for compliance or governance.

Not recommended for: Teams that want zero-install analytics (use GitClear or Swarmia). Anyone who needs a mature, battle-tested platform today. Organizations that can't mandate per-developer tooling installs.

Outlook: The anchor model is the most interesting idea in AI code attribution right now — capturing context at commit time instead of inferring it after the fact is fundamentally better data. The question is whether a 1-month-old solo project can execute on the enterprise engineering intelligence vision before the established platforms add similar capabilities. The Techstars backing and strong privacy posture are good signals. Watch for: team growth, enterprise customer logos, and whether the attribution accuracy claims hold up under scrutiny.