Case study · Product launch

Dispatch a swarm, ship a feature.

Today RaptorLabs launches RaptorCode — a Rust-native, multi-agent coding terminal that fans a single mission out to four specialist agents, each working in its own isolated git worktree, then hands you back a reviewable diff. Here is exactly what that looks like, command by command, on one real task: add Stripe checkout.

4 specialists, in parallel
0 commits without you
1M token context window
15 files, one reviewable diff

The milestone

RaptorCode is the flagship product from RaptorLabs: a local-first, supervised coding terminal that runs autonomous workflows without ever taking the keys away from you. It is not a chat box that pastes snippets, and it is not an unsupervised agent that commits behind your back. It is an orchestrator — one that turns a one-line mission into parallel, contained, fully reviewable work.

RaptorCode ships today for Linux, macOS, and Windows as single-binary builds. This is the story of a single run.

The mission: `raptor swarm run "add stripe checkout"`

You hand RaptorCode a mission in one line. Its reasoning model drafts a role plan (RAPTOR_PLAN.md), then forks four isolated git worktrees under .wt/ — one each for the frontend, backend, test, and security specialists. From that moment they work in parallel, at full depth, never stepping on each other’s files.

RaptorCode swarm dashboard: four agents — frontend, backend, test, and security — each in its own worktree, with live file, step, and token counters. — The live swarm dashboard. Four specialists, four worktrees, one mission — each with phase-colored borders, braille spinners, and live file / step / token counters.

Inside a worktree: the agent loop

Each specialist runs a real tool-executing loop — read, think, write, run, repeat — inside its own sandbox. Sessions start with ultrathink on and reasoning effort at max, so the backend agent reasons about idempotency, partial failures, and retries before it writes a line. Live context-budget telemetry tracks the run against a 1M-token window, with rolling compaction that keeps the system prompt and recent context intact on long sessions.

The backend agent's tool loop streaming: read, think with ultrathink, write create_intent.rs, run cargo check and tests, with a context-budget meter. — Inside the backend worktree: the real tool loop — reading context, thinking at full depth, writing `create_intent.rs`, and running `cargo` checks — with a live context-budget meter.

The handoff: review, then merge

Nothing is committed. Every change lands uncommitted inside its worktree, alongside a written RAPTOR_IMPLEMENTATION_PROPOSAL.md. You run raptor review to see the full picture across all four worktrees, inspect the unified diff, and — only when you’re satisfied — run a supervised merge. The preflight checks for conflicts and green tests before anything touches your branch. You stay in command, start to finish.

raptor review: a summary of changes across four worktrees, a colored unified diff of create_intent.rs, and a clean supervised merge preflight. — `raptor review` — changes summarized across every worktree, the unified diff in full, and a supervised merge preflight. You get a diff, not a surprise.

RaptorCode, on every screen

From the live agentic terminal to the launch site — the same mission, every surface.

The RaptorCode agentic terminal running on a laptop. — The live RaptorCode terminal — v0.3, DeepSeek V4 Pro, agentic mode, ultrathink on.

raptorcode.dev hero on a desktop monitor. — raptorcode.dev — “dispatch a swarm, not a prompt.”

The loop section of raptorcode.dev on a tablet. — From one line to a reviewable diff — the loop, explained.

The early-access request form on a phone. — Request early access from any device.

Why it matters

A whole team, in one terminal. Four specialists attack different facets of the same mission simultaneously — the work that would queue on a single agent happens at once.
Isolation by default. Worktree-scoped tool policies mean parallel work never collides and a hard deny-list keeps catastrophic commands out of reach.
You are the merge gate. Zero commits without your review. The agents propose; you dispose.
Depth over speed-by-default. Ultrathink and effort=max are the starting point — dial them down per session when you want velocity over rigor.

RaptorCode is available now on Linux, with macOS and Windows in invite-only early access — free during early access in exchange for real-world feedback.