conductor is a solid parallel runner — isolated worktrees, multiple claude code agents at once, diffs for you to review. defract is a different category: a lifecycle orchestrator that carries a story from idea to shipped through a gated pipeline — with a visual design stage, agent-reviewed merges, and memory that compounds across every build. one runs your agents. the other runs the whole process around them.
they share one thing. both defract and conductor run agents in parallel, each in its own git worktree, isolated so they don't collide — and both run on claude code as the engine. that's where the overlap ends. they're two separate apps making different bets: conductor bets on being a fast runner; defract bets on the whole path a story takes between “start” and “shipped.”
conductor gives you parallel agent sessions you drive and track yourself. defract is built around the whole path a story takes.
scope → design → architecture → implementation → review → release. each stage is a real gate where you weigh in on the decision; agents do the work in between. when you own the product end to end with no one to hand off to, the structure living in the tool — not in your head — is what lets you ship without dropping the thread.
conductor starts at implementation. defract starts at the story — and runs a design stage that most tools skip entirely.
a design agent renders html mockups live so you see the ui before any code is written. versions you can compare, annotations you can click.
types, lint and tests gate every merge, plus review agents for architecture, security and ux. you sign off on intent and shape, not an 800-line diff.
conductor sessions start largely fresh. defract remembers your codebase, your decisions, and your conventions — and gets sharper every time you ship.
a memory-consolidator agent extracts learnings after each task — including the corrections where you redirected an agent — and feeds them back into the next build. you pick up where you left off without re-loading context, and the tool gets better at building your product the more it runs.
| defract | conductor | |
|---|---|---|
| what it is | a lifecycle orchestrator on top of claude code | a parallel agent runner |
| unit of work | a story carried from idea to shipped | a parallel agent session |
| where you spend time | reviewing decisions at each gate; orchestrating | driving sessions, tracking diffs yourself |
| structure | guided pipeline: scope → design → architecture → implementation → review → release | open sessions you structure yourself |
| design stage | a visual design gate — agent-authored html mockups rendered live, with versions and click-to-annotate | none — design lives outside the tool |
| code review | agents review agents (types · lint · tests · architecture · security · ux); merge gated on sign-off | you review the diffs yourself |
| what you review | purpose-built uis per phase — intent and shape | raw diffs |
| memory / context | persistent memory of codebase, decisions, conventions — compounds over time | no built-in cross-session memory |
| parallel git worktrees | ›yes parity | ›yes |
| models today | claude code (codex · gemini · opencode in v1) | claude code + codex, multi-model compare |
| platform | macos · windows | macos |
| availability | open beta — download now | available now |
we'll be straight: conductor is shipping now, it's mac-native and mature, and it already runs codex and multi-model compare. if you want a fast parallel runner today and you're happy driving sessions and reviewing diffs yourself, it's a reasonable pick.
defract is in open beta — claude code on macos and windows, with codex, gemini and opencode landing in v1. the bet we're asking you to make is on the lifecycle — the whole path from story to shipped, not just the parallel-agent layer. see how we think about running parallel claude code agents, or compare with claude code agent teams.
download the open beta. if you've lived in conductor, we'd especially love your eyes on it.