You can't describe an app you haven't seen — nobody can. Peregrine Code draws your idea first: screens, entities, flows, side by side. You fix it in plain words until it looks right — and the approved picture becomes a living spec that keeps the agent from wrecking your app at 70%. Built by the fastest coding agent we know how to make.
Your API keys never leave your machine · No account, no credit packs · 2 parallel tasks free
Real flow from the editor: idea → structure + mockup → critique in words → spec files born from the approved picture.
Requirements engineering has a name for how humans actually work: “I'll know it when I see it.” It's easier to critique something in front of you than to describe something brand new — so Peregrine puts the picture first and makes the spec a byproduct of your approval.
One sentence in chat. The agent drafts entities, screens and flows — a structure you can point at, not a wall of questions.
“Sidebar left. Add a scheduler. That relation is wrong.” Structure and mockup are projections of one model — a fix anywhere updates both. Undo included.
CONSTITUTION, EARS requirements carrying your “why”, structure, design, phased tasks with verify lines. Separate files, in your repo, yours to edit.
The agent reads the constitution every single turn. Code moved ahead? One click re-checks the spec against reality and shows you the drift.
Vibe tools build instantly — then every new change breaks two old ones, because nothing remembers what you agreed on. Spec tools make you author documents before you've seen anything. Peregrine takes the third path.
“You weren't clear about what you wanted” — because you couldn't be, yet. Visual agreement before code means the last 30% was designed in, not prompted around.
Invariants, decisions and your “why” are injected into every agent turn. If a request conflicts with an invariant, the agent stops and says so — no silent violations, no forgotten decisions.
No “sea of markdown” you author by hand and watch drift. The spec is generated from what you approved, tasks come phased with executable verify lines, and a drift check re-syncs it from code in one click.
Reverse Harness reads any existing codebase — yours, inherited, or a vibe-coded export that hit the wall — and reconstructs the same living spec from it. Every claim marked [certain] or [assumption]; when code and docs disagree, code wins.
Other agents execute a plan step by step. Peregrine asks its own MCP dependency graph which steps are truly independent — and runs them as concurrent implementer agents, each locked to its own files.
Cheap scouts hand the frontier planner a compact brief instead of raw files. Steps touching related modules are grouped via the import graph (get_file_relations), and each group is reviewed the moment it finishes — while its siblings are still implementing.
Speed isn't one feature — it's the sum of removing every wait state in the pipeline.
One toggle in the composer: plans auto-approve, tools auto-run, and the planner skips optional stages. Zero human pauses from prompt to result — for when you trust the task.
When the model requests several read-only calls at once — file reads, searches, git status, MCP queries — they execute concurrently. A batch of five reads costs one round-trip, not five.
The plan is split into independent groups using the project's import graph, then implemented by a dynamic fleet of concurrent agents (the graph decides how many — up to 8), each with strictly disjoint file ownership. Competitors parallelize on faith and stay conservative; a proven graph lets us go wider without losing quality.
Exact-match and semantic answer caches plus provider-side prompt caching. Repeated context is billed at a fraction of the price — and answered near-instantly.
Frontier models never read raw files. A deterministic MCP brief (hybrid search + import graph + file skeletons, zero LLM calls), regex hints from your prompt, and up to three cheap parallel scouts feed the planner conclusions — cutting frontier input cost up to 8x.
Each parallel group is reviewed the moment it finishes — while siblings are still implementing — with an in-place fix cycle. The final full review stays as the unchanged quality gate, and usually passes first try.
Every task shows a live stopwatch and finishes with its wall-clock time. We benchmark against the fastest tools on the market — and publish the numbers.
A semantic index of your codebase — symbols, imports, project memory — kept fresh after every change. It's the brain behind Peregrine — and why the planner doesn't burn a million tokens re-reading your repo, and why parallel implementation is safe at all.
The planner queries the index for relevant code instead of reading files one by one. Grounded plans, a fraction of the tokens.
Import relations decide which plan steps can safely run in parallel — the scheduling signal competitors simply don't have.
Before review, the agent checks what depends on every touched file and which tests to run — regressions caught before they exist.
Conventions, decisions, and onboarding notes persist across sessions. Changed files are re-indexed mid-task, so context never goes stale.
Route each pipeline stage to a different provider: a frontier model for planning and review, a fast cheap model for implementation. Model lists are pulled live from provider APIs — when a new model ships, it's in the picker the same day, no update needed.
Planner on Claude, implementer on DeepSeek, reviewer on GPT — mix Anthropic, OpenAI, Google, and any OpenAI-compatible endpoint in one pipeline.
One-click presets for Ollama and LM Studio — point at localhost and run fully offline, no API key required. OpenRouter preset gives you hundreds of models with a single key.
Your keys are stored locally and calls go straight to the provider. We never proxy your traffic and never take a cut of your usage.
Collected anonymously from active installations — no code content, no prompts, only aggregated counters.
Bring your own keys — we never mark up your AI spend. You pay only for orchestration scale.
Everything that makes a single task fast: Lightning mode, the scout pyramid, parallel implementers, pipelined reviews, stage routing, all providers and local models. Plus 2 parallel tasks with the file-claim registry and git queue.
3–10 parallel tasks and a dependency board between them: queue a whole feature list, tasks start the moment their dependencies land. Early adopters get Pro free.
Desktop app for Windows or a VS Code extension. No account, no license key, no server setup — auto-updates included.
Grab the installer: Windows .exe, Linux .AppImage/.rpm, or the .vsix for VS Code
Add an AI key in Settings — or pick the Ollama preset and use no key at all
Drop an idea into Ideation and watch it drawn — or type a task, flip on Lightning, and watch the timer
Latest release · Windows 10/11 · Linux (AppImage auto-updates; rpm for Fedora) · VS Code 1.85+