{ Features }

What Codira does that nothing else does.

Nine specialized ai agents. Three layers of style context the agents read on every run. Five deterministic patch guards. Three editing modes. Auto-detection across TypeScript, JavaScript, Python, and Rust. The full surface that takes the failure modes of LLMs seriously.

Built for engineering teams adopting ai without giving up architectural consistency or shipping the bugs single-model copilots silently produce.

Download for macOSRead the docs

{ The Agent Team }

Nine agents per change.

Other tools call one model and hope it’s right. Codira calls nine — each with one job, no overlap. Plan, implement, review, security-scan, generate tests; audit existing code with verifier cross-checks; explain unfamiliar codebases; debug failures with candidate fixes. The full team runs before you ever see a diff.

Build
Planner
Decomposes the goal into ordered steps with file targets. Pushes back when the codebase doesn't match the prompt (e.g. wrong path).
Build
Implementer
Writes the patch from the approved plan — full files, never stubs, never "// TODO: implement."
Build
Reviewer
Reads the patch with fresh eyes; rejects with critique when edge cases are missed. Re-runs the Implementer with the critique baked in (2-round cap).
Build
Security
Scans patches for secrets, injection, unsafe deserialization, path traversal — the patterns that get teams paged at 2am.
Build
QA
Proposes test cases the patch should have — happy path + edge cases. Emits in the codebase's test framework (vitest / pytest / Rust #[test]).
Find
Auditor
Read-only bug-finder. Runs /audit on existing code, surfaces concrete findings with file:line evidence.
Find
Verifier
Cross-checks each Auditor finding against the code. Verdicts CONFIRMED / PARTIAL / REFUTED — kills hallucinated bug reports before you waste time on them.
Help
Explainer
Run /explain on any codebase for a 5-section guided tour, or ask a targeted question. New hires onboard in minutes, not weeks.
Help
Debugger
Test or UAT failure? Debugger reads the trace, identifies root cause, proposes 2-3 candidate fixes with honest tradeoffs.

Codira’s failure mode is “the run took an extra minute” — not “the ai broke production.”

{ New in v0.11 }

Agents that already know how your team codes.

Open Codira on a real codebase and the agents arrive knowing your conventions — naming, test framework, error patterns, frameworks in use. Add a one-page team standards file and every PR follows your rules. No fine-tuning. No model training. Three layers of context composed into every agent prompt.

Layer 1 — automatic
Codebase Baseline
Codira scans your repo on first open and infers conventions: file naming, test framework, error handling, frameworks in use. Refreshes after every patch. Today supports TypeScript, JavaScript, Python, and Rust.
Layer 2 — explicit
Team Standards
Your tech lead writes a 1-page .codira/standards.md. Every agent reads it on every run. Version-controlled, PR-reviewable. The starter template installs with one click via the workspace-open banner.
Layer 3 — per-engineer
Personal Overlay
Five taste knobs (comment density, naming flavor, test depth, patch preference, push-back tolerance). Per-engineer, opt-in, never overrides team architecture. Five-knob ceiling held deliberately — personalization beyond fragments the codebase.

When auto-detection and your written standards disagree on a dimension, standards win — you wrote them down on purpose. New hires get the team’s conventions on Day 1 from the IDE, not from three months of review comments. The codebase stays coherent as the team grows from 5 to 50.

See the Team-tier storyRead the stance behind it

{ Patch Guards }

Five deterministic checks.

LLMs hallucinate. They delete functions to “simplify.” They rewrite working code for no reason. They drop exports the prompt never mentioned. They ship placeholder code dressed as finished work. Codira’s five patch guards catch each failure mode before the patch ever lands in your editor — and they run deterministically, not via another LLM judging the first one.

composer · payments/webhook.ts
⌘ K
28export async function handler(req: Request) {
29 const sig = req.headers.get('stripe-signature')
30 const event = parseEvent(req, sig)
33 return new Response('ok')
34}
Deletion Guard
Diffs the patch against current files. If the ai removed code the plan didn't ask for, the guard sends it back.
Grounding Guard
Catches "replace X with Y" patches where X doesn't actually exist on disk. Hallucinated literals get caught before they land.
Regen Guard
Flags when a small requested change produced a wholesale file rewrite. Advisory — Reviewer decides whether to send back.
Stub Guard
Pattern-scan for placeholder code dressed as finished — `// TODO: implement`, empty function bodies, no-op handlers. Critical-severity findings force needs_changes.
Preservation Guard
Compares exported symbols pre- and post-patch. Silently dropped exports (the "add became rewrite" failure mode) get flagged before they break downstream imports.

Most patches have zero findings. The ones that don’t get sent back automatically — you don’t have to catch them yourself.

{ Editing modes }

Three doors. Same agents. Different scope.

Selection edits don’t need a full planner. Feature work doesn’t want a one-shot. Codira gives you three modes that share the same agent pipeline but run different subsets of it — pick the one that matches the size of your edit.

⌘K
Composer
Selection-scoped edits in the editor. Highlight code, hit ⌘K, describe the change. Implementer + 5 guards run inline. No Planner, no Reviewer — the user's selection IS the scope.
/fix
Surgical edit
Targeted single-edit via chat. Runs Implementer + 5 guards + Reviewer. Skips Security + QA — surgical edits don't need the full team. Right tool for typo fixes, refactor cleanups, one-line corrections.
/plan
Multi-step feature
Full pipeline: spec expansion → Planner → Implementer + guards + Reviewer (per step) → Security + QA → auto-UAT against the live dev server. The right mode for any change that touches more than one file.
{ ⌘K Composer in flight }
composer · agents/payments.ts
⌘ K
prompt
Add retry-with-backoff to the Stripe webhook receiver. Max 3 attempts.
Planner2 files · 1 risk
Implementer+18 / −2
Patch guards0 findings
Reviewerchecking…
Security
QA
diff · webhook.ts
@@ -41,7 +41,7 @@ export async function handler(req)
const sig = req.headers['stripe-signature']
- await processEvent(event)
+ await withRetry(() => processEvent(event), { max: 3 })
return new Response('ok')
}
grounded · no unrelated deletions · 1 small diff
{ Time Machine — every run is a save point }
time machine · codira/agents
5 checkpoints
  • 14:02:11
    Refactor billing webhook with retries
    3 files · +18 −2
    HEAD
  • 13:58:44
    Wire Stripe checkout to /api/buy
    5 files · +96 −14
  • 13:51:09
    Add invoice download endpoint
    2 files · +44 −0
  • 13:34:22
    Convert Postgres pool to lazy init
    1 file · +22 −20
    Reverted
  • 13:20:01
    Move webhook secret to env
    2 files · +5 −5

The biggest cost of ai coding is undoing things it got wrong. Time Machine collapses that loop to one click.

{ Slash commands }

Type a slash. Pick a flow.

Each slash command surfaces a different agent pipeline. Seven today — and two inline @-directives (@web, @file) for modifying any run.

/plan
Multi-step feature work. Full agent pipeline + auto-UAT.
/fix
Surgical single edit. Implementer + guards + Reviewer.
/migrate
Coordinated codebase-wide refactor. /plan with an exhaustive file-discovery preamble + a final verify step.
/audit
Read-only bug hunt on existing code. Auditor + Verifier.
/explain
Codebase Q&A or 5-section guided tour. No file writes.
/uat
Manual smoke check against the live preview.
/standards
Open or create the team standards file. Edit it; every agent picks up changes on the next run.

{ Multi-model by design }

Use the right model for the right job. Switch any time.

Five providers ship with first-class support. Route per agent (Planner = Claude, Implementer = OpenAI, Security = Specialist), override per run for any one-off, bring your own keys or use the managed gateway. The user is never locked into a provider — and never locked into a single model’s failure modes.

Anthropic
Claude Opus / Sonnet / Haiku. Default for Planner + Reviewer reasoning.
OpenAI
GPT-4o / GPT-4o-mini. Default for Implementer (code generation strength).
Gemini
Google's frontier line. Routed via gateway, ranks well on long-context tasks.
Grok
xAI's frontier line. Available for users with their own keys.
DeepSeek
Cost-effective backbone for high-volume runs. Strong code performance per dollar.
Frontier auto-select for greenfield
Brand-new projects route to the highest-quality model available on your tier. Mature codebases use cheaper models for routine work; frontier kicks in for hard reasoning steps.
Agent nicknames
Rename Planner to Jennifer, Reviewer to Steph — whatever your team calls them. Per-user, persists, surfaces everywhere the agents appear (chat, picker, UAT cards).

{ Visual workflow }

Codira has a canvas, not just a text buffer.

Four visual surfaces beyond the chat panel. Each one earns its place by removing a class of friction — designing the schema, editing the UI without designer ping-pong, watching the running app, finding code by meaning instead of grep.

Architect Canvas
Visual stack + schema designer. Drag entity tiles, draw relationships, define fields. The Planner reads your Architect doc as ground truth — your data model actively shapes every plan. "Generate Files" emits typed scaffolding from scratch; "Sync to Source" writes canvas edits back to prisma/schema.prisma in place.
Schema auto-load
Open a Prisma, Drizzle, SQLAlchemy, or Django project — the schema canvas is populated from your source before you do anything. Drift toasts fire when manifest or schema files change so new tables and dependencies never slip past.
UI Editor
Click any element in the live preview. Adjust padding / font / color with direct controls. Apply. Skips the "PM says 4px, designer says 6, engineer says yes, ai guesses 8" loop.
Live Preview
Detects your framework (Next, Vite, Remix, SvelteKit, FastAPI), starts the dev server, embeds the output. No tab-switching. UAT auto-runs against this preview after every patch.
Semantic Codebase Search
Embeddings-indexed search over your repo. Ask "where does auth happen?" instead of grepping. Same index powers fuzzy @-mention file resolution in chat.
Image-to-code
Paste a Figma frame or screenshot into the Composer (⌘V). The planner auto-routes to a vision-capable model and builds from what it sees. Up to 4 images per run; PNG / JPEG / WebP / GIF.

{ Everything else }

What makes it usable.

The seven sections above are what make Codira distinct. The grid below — keyboard-first chrome, secrets handling, project memory, and the rest of the daily-driver kit — is what makes it an IDE you actually open in the morning.

Command Palette (⌘P)
Fuzzy file-open over the entire workspace. Sub-200ms cold walk on a 5k-file repo. VS-Code muscle memory.
Rename across workspace (⌘⇧R)
Whole-word, case-sensitive find-and-replace with per-file preview, untick to skip, atomic per-file writes. Pre-fills from the editor selection.
Find & replace + regex
Aa / Ab / .* toggles for case, whole-word, and full regex. Replace All shows old → new inline before you commit it.
Git blame in gutter
Per-line author + age in the left margin. Hover for the full SHA + email + date + summary. Working-tree edits surface as Uncommitted.
Inline diff modal
Click any file in Source Control → Monaco diff modal vs HEAD. No tab switching, no popup to a separate tool.
Env Vars (Keychain)
Per-workspace KEY=value pairs stored in macOS Keychain — never in settings.json. Materialized to .env.local automatically with .gitignore set.
Per-project settings
.codira/settings.json — commit per-repo model picks + agent routing so every teammate and CI run uses the same config.
@web in chat
@web <query> folds DuckDuckGo results into the planner's context for that message. Results posted as a card; no silent tool-calls.
Time Machine
Every ai run is a git checkpoint. One-click revert per run or across the whole session.
Integrated Terminal
xterm + native PTY. Tabs, splits, full shell. Not a web terminal pretending.
ai-run history
Every plan, patch, review, and verdict logged. Audit-grade trail for any change Codira touched.
Git intelligence
Standard git status / diff / checkpoint plus ai-run-aware history.
Project Scaffold
Bootstrap Next, Vite, FastAPI, Remix, SvelteKit, or Tauri projects from inside the IDE.
Clone Repository
git clone wizard with credential helper. Open and clone from the same dialog.
Agent Nicknames
Rename Planner to Jennifer, Reviewer to Steph — whatever your team calls them. Per-user, persists.
Prompt Coach
Inline suggestions while you type prompts. Catches vague asks before the agent wastes a run.
BYO Keys
Paste your OpenAI / Anthropic key; Codira routes directly to the provider. Per-user, per-provider.
Hosted Gateway
Or use the managed wallet — one bill, auto-topup, no API account management.
Auto-Updater
Cryptographically signed updates land in a non-blocking banner. Install when you're ready.
Native macOS
Tauri, not Electron. Rust core + native WebKit + Monaco. ~8 MB DMG, no bundled Chromium.
Crash Reporting
Anonymous, stack-traces-only, file paths redacted. Opt-out in Settings.
First-Launch Tour
Welcome tour the first time you open a workspace. Per-workspace re-nudge in v0.12.10 — a brand-new project gets one subtle 'want the tour?' offer.
Project Memory
.codira/MEMORY.md gets auto-injected into every agent prompt. Persistent context across sessions.
Schema Codegen
Architect schemas compile to typed Drizzle / Prisma / Pydantic boilerplate — keeps the canvas and code in sync.

{ How Codira compares }

If you’re coming from Cursor.

Codira is not trying to be a better version of Cursor’s autocomplete. It’s trying to be the first IDE that takes the failure modes of LLMs seriously — and gives your team the architecture to ship consistent code in spite of them.

Codebase auto-learning
Cursor No
CodiraTypeScript / JavaScript / Python / Rust detected on first open
Schema auto-load
Cursor No
CodiraPrisma / Drizzle / SQLAlchemy / Django — canvas populated from your source on open
Schema reverse-sync
Cursor No
CodiraEdit canvas → write back to prisma/schema.prisma in place; datasource + enums preserved
Team-shared conventions file
Cursor.cursorrules (single layer)
Codira.codira/standards.md + auto-learned baseline + personal overlay (3 layers)
Per-project agent routing
Cursor No
Codira.codira/settings.json — commit per-repo model picks + per-slot routing
Conflict resolution between layers
Cursor No
CodiraStandards beat baseline on conflict; agent gets explicit override directive
Multi-agent review pipeline
Cursor No
CodiraReviewer, Security, QA, Auditor, Verifier each run with one job
Deterministic patch guards
CursorTrust the model
Codira5 TypeScript parsers (deletion, grounding, regen, stub, preservation)
Multi-round review with retry
Cursor No
CodiraReviewer can demand changes; Implementer retries (2-round cap)
Failure analysis on test fail
CursorManual
CodiraDebugger gives root cause + 2-3 candidate fixes with tradeoffs
Codebase Q&A / guided tour
CursorChat with context
Codira/explain — 5-section structured tour with file:line refs
Codebase-wide rename
CursorPer-file LSP rename
Codira⌘⇧R — preview every hit, untick per file, atomic per-file writes
Git blame in gutter
CursorVia extension
CodiraBuilt-in; working-tree edits surface as Uncommitted, not misattributed
Image-to-code
Cursor No
CodiraPaste a Figma frame / screenshot into the Composer; planner auto-routes to vision
Web augmentation in chat
Cursor No
Codira@web <query> folds DuckDuckGo results into the planner's context
Visual stack/schema designer
Cursor No
CodiraArchitect canvas + Drizzle / Prisma / Pydantic codegen
Click-to-edit live preview
Cursor No
CodiraUI Editor — direct padding/font/color controls
ai-run history
CursorChat scrollback only
CodiraTime Machine — every run is a git checkpoint, one-click revert
Inline edit hotkey
Cursor⌘K, single-shot LLM
Codira⌘K, runs Implementer + 5 guards (+ optional Reviewer)
Env vars in OS Keychain
CursorPlaintext file
CodiramacOS Keychain — never in settings.json; auto-materialized to .env.local
Provider support
CursorOpenAI + Anthropic
CodiraAnthropic + OpenAI + Gemini + Grok + DeepSeek (5)
Per-agent model routing
Cursor No
CodiraPlanner = Claude, Implementer = OpenAI, Security = Specialist, etc.
Managed credit wallet
Cursor No
CodiraOne bill, auto-topup, switch any time
BYO API keys
Cursor Yes
Codira Yes
Native macOS build
CursorElectron (~600 MB)
CodiraTauri (~8 MB DMG, no bundled Chromium)
{ Start building }

Nine agents. Three layers. One IDE.

Download Codira and open it on a real codebase. The agents will know how your team codes within 30 seconds. The docs walk you through the rest.

Download for macOSRead the docs