Most surfaces, one walkthrough.

Download for Windows, macOS, or Linux, run the installer, point at your first repo. A one-time, free sign-in, then works fully offline.

How the in-app auto-update works, the manual override, and recovering from a blocked update.

Run the app as its own separate server on its own port and data profile, so it never attaches to a dev server you run from source.

The person-owned brain that follows you across every AI tool, your repos, and your life. Ask it locally, connect it to Claude Desktop / Cursor / ChatGPT via MCP, read it from any app with a scoped token, open it in Obsidian, share a slice.

Invited to a team? Accept, install the desktop app, bind it, and turn on streaming, in one walkthrough for the invited member.

An orientation tab that links to the RepoOps bootstrap prompts and dashboard quickstart in the shared hosted doc-viewer.

The person-scope brain you own, on its own page.

Manager-orchestrated agent runs and where each one landed.

A short daily record of what you shipped, from your own session evidence.

Know what to do next. Spend, ship-readiness, vulnerabilities, brain pulse: the one tab to open each morning.

Triage-first alerts ranked by blast radius. Capped, quiet, and suppressed when a lesson already covers it.

Universal cross-repo file index. Substring search across paths and titles.

The queued and running actions across your repos, with status and one-click open.

Every multi-step workflow run, its slices, and where each one landed.

The /team landing: connected devices, invites, budget alerts, server-owned policy.

The hosted /dashboard view: what stays in the cloud, what stays on each laptop.

Bring your own agent: the recipe for a morning team standup prompted over the RepoOps MCP server.

Your standing situation report. One signal hub for spend, ship-readiness, the queue, and what your next session will load.

Everything your AI built, following you across repos, sessions, and machines.

See one multi-agent graph run as a single accountable unit: its agent nodes, edges, shared-state timeline, cost rollup, and outcome receipt.

The left end of every loop: what a loop is declared to do, before it runs, joined straight to its outcomes.

What changed in the brain between two points.

Live agent sessions in flight, updated as they run.

Your app tells you why it is slow, before you have to ask. Own-runtime health, opt-in terminal capture, and a hosted fleet view of which installs are flapping.

The hosted fleet rollup of own-runtime self-audit findings, grouped per install, showing which machines in your team are flapping or wasteful and an applied fix's measured before and after.

Drill into one Claude Code run: a cost-weighted span waterfall from session to turn to tool.

The chain from prompt to edit to result, reconstructed for any change.

The filterable PR index across every tracked repo. The conversation record, indexed.

End-of-session journal entries: what got built, what is next, what slowed us down.

On-demand plain-language summaries of any repo you track.

The RepoOps Signal Layer: the raw detections that feed every higher surface.

Non-destructive rewind: snapshot the working tree on demand, restore any prior state without a commit or moving HEAD.

The always-on background agent that captures your Claude Code work and keeps your dashboard current with no server running: no inbound port, inert until you opt in, redaction at the point of writing, a real OS service on every platform.

Your organization GitHub repositories, inventoried from the RepoOps GitHub App.

The live health of your team always-on RepoOps capture daemon across every bound device.

Incoming items to triage before they reach the review queue.

The anti-pattern rule engine: list, tune, test, and author rules with no code file.

A graded scorecard for your CLAUDE.md against the operating-manual checklist.

Know it will not ship broken. Trust boundaries, BYOK, threat model, plus a live footgun scan.

Turn a security detection into a case somebody works: a lifecycle, a clock your team sets, a playbook over the containment verbs that already ship, and a guard that stops the next one. Evidence never leaves the machine that observed it.

The hosted Incidents tab lists every prevented incident from your team event store, with the guarding-action verb and the dollars it saved.

What each agent and tool is allowed to touch, and where the boundaries sit.

The reach of a change before you ship it: what it touches, what it could break.

The declared read and write scope for each surface, enforced at the boundary.

Runs the same checks CI would, in about 90 seconds, before the PR opens.

Review a diff line by line: brain decision rules, security checks, and blast radius on the changed hunks.

Cycles to merge, reviewer load, review depth, and open-to-first-review latency, with honest nulls where the store is silent.

Env-var registry: which file reads what, plus the Doctor's plain-language footgun checks.

Production alerts auto-correlated to the change and the AI session that likely caused them.

The hosted Guard and Manage controls for the team.

A guided go-live preflight plus deploy and domain runbooks.

A read-only advisory-control posture across every inventoried repo.

Arm or disarm the advisory controls RepoOps can apply, per repository.

The tenant-scoped service-connector vault.

The shared team queue of code changes and PRs awaiting human review, with reviewer and status per item.

A ranked leaderboard of accountable, verified agent work.

Drill into a failing run to find the root cause.

Your work over time, as a builder profile.

The proof-of-work record: what shipped, tied back to the intent that asked for it.

Five cheaper-loop plays read back to you, each with the findings that tripped it and the dollars it bleeds. See the waste before the invoice does.

A ranked, plain-English story per loop: a session shipped a PR, it introduced a defect, and a lesson now guards it.

The hosted rollup of prevented incidents and dollars saved from measured outcome events over the last 30 days, linked to the guarding Lessons and Decisions.

What share of merged work AI authored, every slice labeled by its evidence tier. Slices sum to exactly 100.

How AI-coauthored and bot-authored work attributes: one vendor identity table over co-author trailers and bot author identities.

Per-developer AI-tool usage pulled from the vendors' own admin APIs (Cursor, GitHub Copilot), surfaced as a labeled evidence source beside the local evidence.

Close the loop on your coding agents so the loops you run improve instead of just running.

One supervisor dashboard for the architect overseeing an autonomous agent fleet.

The public verification page: paste an attestation, get an independent yes or no.

Your verified memory as a leaderboard: which bars exist, the pass rate over time, which loops clear which bar, and where a regression crept in.

One artifact per benchmark run listing which of the eight controls actually ran, published as an open schema so any vendor's lift can be scored against it, including ours.

One verdict on whether a claimed token saving actually held.

A measured before and after receipt per adopted routing proposal. Not yet measured until the window fills; never a projection.

Reconcile your Claude bill against locally captured token counts.

Know what it cost. Combined-mode Claude Code telemetry across every tracked repo.

The weekly or monthly leadership rollup, assembled from the same modules the source tabs read.

Per-session token spend with heuristic and LLM-driven recommendations on where to save.

Where the spend goes, by workstream: deterministic lexical topics, pinnable semantic generations, and an explicit initiative rollup.

Does AI adoption connect to outcomes: per-developer adoption joined to quality, cost per merged PR, and review depth, with an honesty-gated correlation. Association, not causation.

Per-developer session timing, prompt cadence, tools, files. The contractor-governance surface.

The full archive of captured user prompts. Declared intent, read back: search what your team actually asked their AI.

Per-client invoice export with proof-of-work line items.

Full session transcripts, searchable turn by turn.

Edit each repo's tier mappings and open a PR with the change.

Production LLM telemetry: by-tier, by-surface, hot prompts, real Anthropic billing.

The full model: revenue, cost of goods, margin floors, and the levers that move them.

A composite Spend-Efficiency grade over six levers: defaults, routing, caching, context, visibility, ROI.

Telemetry-vs-invoice reconciliation: expected cost recomputed from your own telemetry, joined against Anthropic's usage and cost reports, findings with an evidence bundle finance can dispute with.

A zero-model-token audit that reconciles local Claude Code telemetry against the Anthropic Admin Usage & Cost API and writes an evidence bundle for finance.

The same audit as an .mcpb extension inside Claude Desktop: per-user install for managed laptops, Admin key in the OS keychain, optional background sweep.

One unified cross-provider view of real metered LLM spend from two lenses that are never summed: provider-reported (authoritative, org-wide) and locally-captured (attributed to this install), each line carrying a per-token, day-level, or per-call precision band, with unconnected providers shown as not connected rather than $0.

Vendor spend plus pricing model. The aggregated economic view.

Cross-developer activity ledger with integrity proofs. Per-binding drill-down.

Team vendor spend and budget alerts.

The hosted Today, Watch, and Spend rollups in one place.

A CFO and CEO rollup: spend, prevented incidents, ROI, and a 30-day trend.

A PM rollup: ship-rate, deploy frequency, and median time-to-merge.

Proof that your RepoOps memory is versioned and tamper-evident.

How your accumulated memory compounds into a moat.

Explore the knowledge graph of brain files, code, and concepts.

Where two repos decided the same topic opposite ways.

Your brain in the open standard: export a portable OKF bundle.

The team's shared playbooks, reusable across repos.

Last night's lesson proposals: review, accept, reject. The reason your second project goes faster.

Ask your brain a question in plain language and get an answer grounded in your own notes.

The Telemetry mode of Ask the brain: metric questions answer free, anything else runs a bounded tool loop over your telemetry on your own Anthropic key.

One read surface over what the team knows, what it learned this week, what it prevented, and who is working on what.

The active lesson store. Every accepted lesson regenerates into CLAUDE.md and AGENTS.md on next run.

The ADR log: every architectural call with the reasoning. The receipts behind the code.

The error-learning loop: what broke, what fixed it, what rule prevents it next time.

Unresolved architectural questions, each with the event that triggered it.

Named, reusable recipes: moves your team makes on purpose, plus the anti-patterns you avoid.

The domain vocabulary specific to this project, plus the terms you deliberately do not use.

The freshness and coverage of your brain: what is decaying, what is missing.

A hosted view over your team's persisted graph store, showing node counts by type, edge counts by source, and confidence bands from a distilled, redacted snapshot the desktop streams on its hourly brain cycle.

The cross-reference web between brain entries, and the links worth adding.

Brain references that point at moved, renamed, or deleted targets, flagged for repair.

The memory that captures itself as you work, no manual note-taking required.

Force-directed graph of brain cross-references. Node size scales with influence.

Draft end-of-session entries generated from the work, ready to review and keep.

A PR description drafted from the diff and the session, ready to edit.

Your skill trajectory: what you are getting better at, and the next thing to learn.

When and where the work happens, as a calendar heatmap.

What your loops produced, measured and read back to you.

Post a number that actually means something. Generated locally, downloaded on click.

Surfaces the workflows you actually repeat and turns the top one into a skill file.

Cross-repo pattern library: what is shared across 2 or more repos, what is worth promoting.

The brain pulse rolled up across every connected developer.

The hosted brain read surfaces and what each one exposes.

The team quality score and how it is computed.

Coaching signals rolled up across the team.

Brain freshness and coverage across the team.

Your brain is already a valid Obsidian vault. Point Obsidian at it, install Dataview, get a graph view plus live dashboards. Edits flow back through the write-trust guard.

Mint a scoped, revocable read token and read a slice of your brain from any external property. Copy-paste REST and JS snippets plus a Google Sheets Apps Script template.

A context-health score from 0 to 100 over the rule engine health surface.

An auto-generated descriptive wiki over your repo source.

A voice interface: record a question and get a transcript.

Anything you did twice becomes a proposed prevention rule you accept, reject, or snooze.

A copy-paste gallery of named agent loops, each with a budget cap, a separate verifier, and what it costs on your own telemetry.

The hosted audit log across your team.

The hosted first-run checklist: connect, publish, confirm telemetry.

Add or remove tracked repos at runtime. Manage clients, accounts, BYOK keys, telemetry privacy.

Ask for a change from the dashboard: submit a feature, fix, or cleanup, triage it in Manage, and let the request builder open one human-gated PR per queued request.

The container you run a customer engagement inside: customer, vertical, lifecycle status, and a scope that points at the brain slice, per-client budget, and MCP tenant RepoOps already ships.

Every privileged action, who did it, and when. The tamper-evident record.

The local-first cryptographic governance surface: ledger verification, redaction posture, policy, file integrity.

The curated, reusable prompt library for the team. Distinct from the captured-prompts archive under Spend.

The portable brain plus skills plus docs prompt. Port this setup to any repo in one paste.

The full gold-standard repo setup prompt: every convention this project has earned.

The four-step install for the brain dashboard in any repo.

The hosted admin surface: members, roles, org policy.

The hosted, tamper-evident audit log for the team.

Team governance: policy, controls, and enforcement.

Team share links and their scopes.

How team licenses work, how billing rolls up, what happens if a license lapses.

Account settings: invites, role management, the linking-code flow for bound devices.

A one-shot launch-readiness audit prompt you can run against any repo.

The admin console: seats, subscription, members, policy, governance, and budget.

Configure single sign-on with your SAML 2.0 identity provider.

Create revocable read-only links to the team rollup.

Privacy-respecting, team-scoped aggregate counts of which hosted tabs your team visits.

The map of routes, modules, flows, and entry points, for when you or your AI need to find the right file.

Every file and folder with a single line of purpose. The fastest way to onboard a codebase.

Every route, page, and endpoint with shipped-or-planned status.

The feature index: what shipped, what is planned, what is deferred.

The canonical HTTP API contract: every endpoint, method, auth, request, response.

Every database model, column, index, and foreign key, paired with the migration that created it.

Suite reference: runners, fixtures, CI jobs, coverage.

Every external vendor: env vars, install steps, failure modes, monthly cost.

Build and pipeline deps: what each is, risk profile, compromise scenario, patch path.

One searchable index over every brain and docs reference for this repo.

Crons, hooks, background jobs: what runs without you, when, and what proves it ran.

The design system: tokens, type, motion, light and dark.

The running log of design decisions and their rationale.

The component registry: every reusable variant, what uses it, and the boundaries.

The canonical verb spine and what each verb owns across the product.

Phases, progress bars, the track filter. The single source of truth for what is shipped vs. queued.

The pillars, moats, and positioning: what RepoOps is for, what it is not, what is the moat.

What the Weave comparison covers and how it is sourced: their published claims with as-of stamps, our claims linked to shipped surfaces.

Concrete users behind each label: Vince (solo vibe coder), Eli (eng manager), Andy (agency owner).

What we watch, what counts as a bad signal, and the thresholds that trigger action.

Parked ideas: what has been considered and consciously deferred.

The registry of every shipped docs page plus walkthrough video.

The brain index: the map every session reads first.

The four principles that keep AI-written code disciplined.

Think before coding, simplicity first, surgical changes, goal-driven execution.

Bring your own embedding key: how vector indexing uses it and the fallback when it is missing.

How outbound email meets compliance: unsubscribe, sender identity, and rate rules.

The Partner Proof Spec v1 for vendors: emit your enforcement decisions as NDJSON and they land in the accountability ledger as tamper-evident receipts.

A flat index of every dashboard tab and the doc that covers it.

The hosted reference index for the team scope.

A read-only catalog of the Claude Code dev-time toolkit across your tracked repos.

Many brains working the same problem at once, with shared context.

A shareable, public, read-only slice of a brain.

A society of brains that teach each other across repos and people.

The brain and skill marketplace: what you can publish, what you can install.

Who can read and write each brain slice, and the write-trust guard behind it.

What lives in hosted Labs and what stays desktop-only.

A live feed of pattern detections across repos, tenants, and query gaps.

An append-only signed log of every cross-* event.

One control panel for every cross-* axis: session, repo, tenant, and realtime.

A 30-day leaderboard of cross-* activity per axis.