claude code's agent teams are the native floor: free, built-in, parallel agents coordinating from your terminal. defract runs on the same claude code — and adds the part the terminal doesn't: an opinionated lifecycle with gates, a visual design stage, and a desktop app where you review intent per phase instead of driving every step yourself.
defract runs on claude code — it doesn't replace it. agent teams are claude code's own way to run several agents in parallel, each in its own git worktree, coordinating through a shared task list from the terminal. that's a real, free capability, and defract uses the same engine underneath. the question this page answers isn't "which runner" — it's whether you want to drive the agents yourself, or have a process drive them for you.
with agent teams you direct the work in natural language — you decide the stages, the order, and when something's done. defract decides the shape so you don't have to.
scope → design → architecture → implementation → review → release, with a gate at each. the agents do the work between gates; you weigh in at them. the structure lives in the tool instead of in your head and your prompts.
agent teams are terminal-first — split panes, one per agent. defract gives you a surface built for reviewing, not just watching.
you review intent and shape on a purpose-built ui for each stage — scope, design, architecture — not by scrolling diffs across terminal panes.
a gated visual design step in the lifecycle: agent-produced, you approve it, it drives implementation. not a separate tool you hand off to.
agent teams give you the raw hooks; you write the enforcement. defract ships the gates.
types, lint and tests gate every merge, plus review agents for architecture, security and ux — code only progresses once it's signed off. the same coordination agent teams expose as scripting, defract gives you as a process out of the box.
| defract | claude code agent teams | |
|---|---|---|
| what it is | an opinionated lifecycle app built on claude code | claude code's native multi-agent mode |
| structure | enforced lifecycle: scope → design → architecture → implementation → review → release | you coordinate agents yourself, in natural language |
| interface | desktop app with per-phase review uis | terminal-first (split panes per agent) |
| design | a gated visual design stage in the lifecycle | not built in |
| review & gates | agents review agents; merge gated on sign-off, out of the box | hooks you script yourself |
| parallel git worktrees | ›yes parity | ›yes (native) |
| engine | your claude code (codex · gemini · opencode in v1) | claude code (native) |
| cost | app in open beta; bring your own claude (pay anthropic directly) | included with claude code |
| platform | macos (windows · linux in v1) | wherever claude code runs (terminal) |
we'll be straight: agent teams are free, native, and zero-install — they're already in the claude code you run, the git-worktree isolation is built in, and anthropic ships improvements on a fast cadence. if you live in the terminal, want parallel agents you drive yourself, and don't want another app in the loop, the native floor is a good floor. start there.
defract is for the next step: when running the agents isn't the hard part anymore — keeping a multi-stage build coherent, reviewable, and shipped is. we add the process and the surface on top of the same engine. not a replacement for claude code; a way to run your process through it.
download the open beta. it runs on the same claude code you already use.