Stop re-explaining your code.
Oh quietly captures the reasoning behind every AI-coding session — across Claude Code and Codex — into one shared Team Brain. When a teammate's agent needs to know why, it just asks. And private Insights show you — only you — where your AI time and tokens actually go.
The real tax isn't onboarding. It's re-explaining.
AI writes most of the code now — but the why behind each change dies the second the chat closes. PRs show what changed, never why. So every decision you already made comes back as a question.
You explain the same decision, again and again.
The reasoning is already captured. Their agent asks it.
One quiet pipeline, from session to answer.
Capture is hook-driven, not a daemon. Only reasoning is kept, secrets are scrubbed locally, and raw sessions never leave your machine.
Capture
A Stop/SessionEnd hook spawns a detached oh capture that reads only what's new. Never a daemon. Never blocks your turn.
hook-drivenDistill
Only reasoning is kept — your prompts, the agent's explanation, and one-line tool summaries. Raw diffs and file dumps are dropped.
reasoning onlyEmbed & store
Reasoning is embedded and upserted into a shared Supabase + pgvector store — your Team Brain. Raw sessions stay local.
supabase + pgvectorAsk
A teammate's agent calls ask(…) and gets ranked, cited excerpts — similarity plus a recency boost, so reversed decisions surface the current answer.
ranked + citedWhat leaves your machine is reasoning — and only reasoning.
Reasoning-only embedding
Prompts, the agent's explanation, and one-line tool summaries — that's it. Raw file dumps, diffs, and tool output are never embedded.
Secrets scrubbed locally
Keys, tokens, and credentials are masked with «secret» before anything leaves your machine. Scrub runs at capture, not after.
Raw sessions stay local
They already live in ~/.claude and ~/.codex. The shared store holds only the scrubbed, embedded exchanges — nothing more.
Claude Code and Codex, sharing one memory.
Capture and ask are wired into both tools through the same hook + MCP server. A decision made in Codex is answerable from Claude — and the other way around.
See where your vibecoding actually goes.
Your team pays for agent seats and tokens every month with zero visibility into where they go. oh insights reads the sessions Oh already captures and shows you your time anatomy, token economy, and friction — plus a quiet nudge when a session starts rabbit-holing.
Only you can see them
No --who, no team tables, no manager roll-ups — by design, not by toggle. The moment a teammate or boss could read your numbers, capture turns adversarial. So they can't.
What your team sees instead
Deflection counts: "Oh answered 14 questions this week that would have been interruptions." A statement about what Oh did — never about how any dev works.
The rabbit-hole nudge
When a session starts spiraling — corrections piling up, tokens burning on the same file — Oh taps you on the shoulder, quietly. Nobody else gets a copy.
Ask-why keeps the team. Insights opens the wallet.
Neither sells alone: ask is why your team keeps Oh installed every day; Insights is why it's worth a line on the card that already pays for your agent seats.
Self-host
- Bring your own Supabase + OpenAI key
- The full pipeline: capture · ask · insights
- You own every byte, end to end
- Set up in 2 minutes, below
Team
- oh login — no SQL, no shared keys, no setup doc
- Per-user auth; your rows are yours, enforced by the database
- We run the store and eat the embedding bill
- Insights stay individual-only; the team gets deflection counts
Design partners
- AI-native teams of 3–15 devs
- Already living in Claude Code / Codex
- Weekly feedback, a direct line to us
- Shape the product before it has a price
Up and running before your coffee.
Clone, link, init, backfill. The CLI wires capture + ask into both Claude and Codex for you — backing up every file first.
$ git clone <this-repo> && cd oh $ npm install # also builds (prepare) $ npm link # puts `oh` on your PATH $ oh init # name · shared Supabase · OpenAI key $ oh backfill # seed from your existing history # then restart Claude / Codex to load the MCP server + hooks
Paste this into Claude Code or Codex — your agent does the setup.
It asks for your name, OpenAI key, and the team's Supabase URL + sb_secret_… key, then wires capture + ask into both tools and seeds your history. Get the team's URL and key from whoever set up your shared project.
Set up "Oh" (our team's shared AI-coding memory) on my machine, end to end. Oh
captures our Claude/Codex sessions into a shared store so we can `ask` why code
or a decision is the way it is instead of interrupting each other.
Do the following, adapting as needed and showing me any errors:
1. Clone & build (if ~/oh already exists, `cd ~/oh && git pull` instead):
git clone https://github.com/21J3phy/Oh.git ~/oh && cd ~/oh && npm install
npm install runs the build (a `prepare` step). Optionally `npm link` to get an
`oh` command on my PATH — if it fails on permissions, use `node ~/oh/dist/cli.js …`.
2. Ask me for (a) my name, (b) my OpenAI API key, and (c) the team's Supabase
URL and secret key (sb_secret_…). Then run init non-interactively with my answers:
node ~/oh/dist/cli.js init --yes \
--author "MY_NAME" \
--supabase-url "TEAM_SUPABASE_URL" \
--supabase-key "TEAM_SUPABASE_KEY" \
--openai-key "MY_OPENAI_KEY" \
--repos "21j3phy/oh"
This writes ~/.oh/config.json and wires capture hooks, the `ask` MCP server,
and the `ask-why` skill into both Claude Code and Codex (backing up each file first).
3. Seed my existing history into the shared store:
node ~/oh/dist/cli.js backfill
4. Tell me to fully restart Claude Code and Codex so they load the new MCP server,
hooks, and skill. (Codex may ask me to trust the new hook — approve it.)
When done, confirm with `node ~/oh/dist/cli.js status` (chunk count should be > 0).
After that, in either tool I can just say "ask why we did X".
Shared memory for your AI-coding team. Never re-explain a decision twice — and finally see where your tokens go.