Documentation
Corvi documentation.
Start with the quickstart, read the concepts when you want the model, and reach for the CLI and configuration reference for exact behaviour.
Quickstart
Concepts
The planning model
Draft → review → synthesize: how three model passes turn a sentence into a plan.
Read →Grounding & retrieval
The workspace broker, the retrieval seed, and why every plan step cites real code.
Read →Egress & trust
Opt-in egress, fetch and spend budgets, the audit log, and how untrusted content is wrapped.
Read →Repo memory
How Corvi learns your repo's conventions over runs — where they're kept, and how to forget them.
Read →Guides
Run headless
Generate plans from the terminal or CI with corvi run — export, resume, budgets.
Read →Run as an MCP server
Serve your plan library over MCP so any client can list, read, dispatch, and verify plans.
Read →Plan in Claude Code
Install the plugin and your plan library is in Claude Code — reads local, every tool gated.
Read →Integrations
Route to your own MCP servers and agent skills, then hand a plan to Claude Code, Codex, or Cursor.
Read →Reference
CLI reference
Every corvi command and flag: run, mcp-serve, mcp-files-serve, capabilities, costs, symbolicate.
Read →Configuration
Environment variables, the data directory, model presets, and the plugin / MCP config.
Read →API & provisioning
The control-plane API reference, plus the Terraform provider and Pulumi package.
Open ↗Changelog
A running log of what's new in the beta. We ship a release about every two weeks; here's what each one added.
- Plan-approval gate — a plan is the contract before it runs. It must be approved before it executes or opens a PR, and re-approved if you edit it after sign-off.
- See a change's blast radius — a plan now surfaces the callers and dependents a change ripples into, not just the files it edits.
- Repo memory you can review and forget — Corvi learns your repository's conventions over time and applies them to the next plan; read what it has learned, and clear any of it.
- Per-run spending cap — set a dollar ceiling for a run and it stops cleanly at the limit instead of spending past it.
- Live execution status — a running plan shows elapsed time and flags when the agent has gone quiet; a finished run shows what it took, start to end.
- See the cost before you commit — a price range previews before every run, $0 when you run on-device, with a running tally of estimate against actual.
- More precise grounding — opt in to exact symbol and cross-file references across Swift, TypeScript, Python, Go, Rust, Java, and Kotlin.
- Guided first run — a short setup walks you through connecting a model, choosing a quality preset, and pointing Corvi at your repo.
- Optional cloud sync — sign in with email and password, magic link, Google, or GitHub, and sync your plans across your own devices through a blind, end-to-end-encrypted store.
- Free and open source — every feature is available to everyone, no paid tiers.
- Quick Plan — a code-grounded sketch in under a minute, upgradeable to the full reviewed plan in one click.
- Plans that cite real code — retrieval runs through a security boundary and every step resolves to a real file and symbol, not a guess.
- Know what left your machine — outbound calls are opt-in per source and budgeted, with an audit of exactly what was sent.
- Choose the model behind each pass — presets tuned for quality, value, or fully on-device, with a run breakdown of time and cost.
- Bring Corvi to your own agent — it runs as a tool server, so the agent you already use can pull a plan directly.
- The multi-model engine took shape — one model drafts, a second reviews it like a senior engineer, a third reconciles the result, so one model's blind spots don't reach the plan.
- Plan types — feature, bugfix, refactor, and migration each shape how the work is structured.
- Corvi asks when it's unsure without stalling — clarifying questions that don't block the run.
- Real-time co-planning landed — end-to-end encrypted, so the work stays private.
- Code-grounded planning — Corvi began reading your repository so plans point at real files and symbols.
- A trust boundary that decides exactly what the engine may see, scoped to the workspace you chose.
- Relevant retrieval — a repo map and on-device embeddings find the files that matter.
- Room to extend — discover and route to your own tools and skills per run.
- The first Corvi — a native macOS app that turns a sentence into a written implementation plan.
- A live-preview editor that stays editable while output streams in — your text is never overwritten.
- Local-first from day one — plans stored on your Mac, bring your own model key.
- The raven took shape — Corvi's mascot-led design language.