Honesty for your agents

Freeze the plan. Review it independently. Then build — so AI work cannot fake DONE.

Portable governance for any repo. Your apps keep the product runtime; this kit keeps the plan honest between sessions.

$ ok check-ok --topic "side-research"
check-ok: scaffolded docs/reviews/…
$ ok check-ok --path docs/reviews/…
verdict: pass

Download Mac console Clone on GitHub

Scenarios · Docs · Releases

Overseer honesty loop: Think and freeze, freeze review with re-review on findings, Auto build, build verification with re-check, Check OK pass in the center

Check OK

  • Any work — type Check OK (or run ok check-ok) on a side spike, a draft, or a full phase. No roadmap row required.
  • Same honesty loop — freeze the plan, review it independently, then build and verify. Findings go back around until pass.
  • Anywhere you work — Cursor, Claude Code, or the terminal. One gate for ad-hoc work and larger phased projects.

Roadmap · Handover · Lanes

  • Roadmap — the phase board: what is planned, frozen, building, or done.
  • Handover — the session baton: what just landed and the one next prompt to paste.
  • Lanes — more than one roadmap/handover pair when several streams of work run in parallel.
  • Hygiene — sync roadmap and handover every session; commit the feature branch; no dirty tree at close.

The failure mode

Why governance honesty matters

AI-assisted development breaks down at the boundaries between sessions.

Overseer Kit makes skipping honesty expensive — not by running your product, but by governing how phased work proceeds.

The loop

How it works

Lock the plan, check it independently, then build only against that freeze. Living docs carry the baton between chats.

  1. Lock the plan

    Design freezes what to build and how. No build claims DONE until an independent freeze review passes.

  2. Keep docs truthful

    A phase board and a session handover stay aligned with real work — so the next chat starts from facts, not memory.

  3. Spend models wisely

    Use deeper judgment for design and review; keep mechanical build on a cheaper tier. The kit is the rulebook; your IDE dials the model.

  4. Close clean

    Before you stop, sync living docs to real VCS state and verify the build claim. Green tests alone cannot fake completion.

Structure at a glance

How the kit is built — work lanes, version-control options, safety layers, and the kit vs your apps.

Work lanes pair a phase board with a session handover. Keep lanes few — not one per ticket.
Single-lane phase board paired with handover versus optional multi-lane kit and product paths
  • Single-lane default: phase board ↔ handover
  • Optional multi-lane: each lane maps to its own living-doc pair
GitHub-only is a full baseline. MuseHub deepens history when you want it — it does not unlock exclusive core features.
Version-control options from git-only to Muse with GitHub mirror to Muse-only
  • git-only — GitHub canonical
  • muse+git-mirror — Muse canonical + GitHub mirror
  • muse-only — Muse canonical; no GitHub mirror
Baseline safety is always on. Extra checkpoints and dual-control bind when your domain needs them — they never replace freeze review.
Layer stack from baseline governance to domain checkpoints to honesty ledger
  • Baseline — living docs, phases, freeze review (always on)
  • Checkpoints — bind when you have verify scripts
  • Dual-control ledger — bind when money or publish stakes require it
The kit ships sockets. Your apps own domain checks and product UX.
Overseer Kit clone through ok init to config and living docs, then consumer domain packs
  • Kit clone → ok init → config + living docs
  • Consumers own verify scripts and product UX

Get started

This site does not run the console and does not mint session credentials. Open a local process, then use the UI in the browser or desktop shell.

Path 1 — Download Mac console preferred · Apple Silicon

  1. Confirm Python 3.11+ (python3 --version).
  2. Download the signed Apple Silicon .dmg via the button above (Release v0.1.0).
  3. Set OVERSEER_REPO_ROOT to a repo that already has .overseer/ from ok init. Without it, the app binds the bundled kit inside the app.
  4. Open the app and confirm the bound path before any write action.

Apple Silicon Mac · signed and notarized · Python 3.11+ required. Windows/Linux signed installers are not published yet.

Path 2 — Browser (ok app)

  1. From a governed repo: ok app --open.
  2. Open http://127.0.0.1:8765/ on this machine only (this public page is static).
  3. From that same terminal, paste session_credential and csrf_token into Session bootstrap → Connect.
  4. Credentials last for the process only; never commit them; this website never mints them.

Path 3 — Dev desktop

  1. From kit root: ./scripts/bundle-desktop-kit.sh, then cd desktop && npm install && npm run tauri dev.
  2. Same bind rules as Path 1; needs Python 3.11+ plus Rust/Node for dev builds.

The console is bound to one local checkout — not to this website and not to arbitrary remote repos.

Operator detail: Desktop operator runbook · Release index: v0.1.0 · Clone guide: Git-only quickstart

Optional deepen with MuseHub

Run fully on GitHub alone. When you want stronger continuity — Muse as the memory layer, GitHub as the mirror — flip the regime. Same ok commands. Not a second agent product.

See version-control options · Start Muse-backed: ok init --regime muse+git-mirror

Where to go next

This site explains Overseer Kit. Day-to-day product UX stays in your apps.

GitHub

overseer-kit — clone, ok init, issues.

Docs

Docs on this site · Adapter pattern · Quickstart

Local console

After ok app is running: Open loopback console — see Get started.

Scenarios

Scenario gallery — video, research, classroom, and more.

GitHub today → Overseer Kit → Muse when ready

Scenarios

Short persona stories — who uses the kit and for what jobs.

Open the scenario gallery →