superset is genuinely good at one thing: launching a lot of agents in parallel across isolated git worktrees, without you babysitting any of it. defract is built for a different axis. superset scales how many agents you run; defract scales how structured the work is — every task through a visual design stage, implementation, and a gated review before anything ships. local-first, your own anthropic key.
they share a primitive, not a thesis. both superset and defract are desktop apps that orchestrate coding agents in isolated git worktrees, so you can run work concurrently without clones or conflicts. that is where the overlap ends. superset is a runner — its bet is raw fan-out and broad agent support, and it leaves the process to you. defract is a lifecycle — it runs each task through story, design, architecture, implementation, and review, and the structure is the product.
superset launches agents; the process lives in your head. defract runs each task through a fixed lifecycle — story → design → architecture → implementation → review → release — so the steps are explicit and repeatable.
raw parallelism is a throughput win, but throughput is not the bottleneck for most teams — consistency is. ten agents fanned out with no shared process produce ten different interpretations of “done.” defract makes the path every task takes the same one, which is what makes the output reviewable instead of a pile of diffs to reconcile.
superset is an editor and a runner — there is no design step and no built-in review between an agent finishing and the change landing. defract gates both ends.
before any implementation agent starts, defract produces a rendered UI reference the agent works from — not ambiguous prose. it is the stage that most reduces drift on anything with an interface.
a security reviewer (OWASP-anchored), a refactor reviewer, and a generic reviewer evaluate the work against the original story. code only progresses on sign-off plus your approval.
superset is agent-agnostic — its strength is breadth across CLIs. defract makes the opposite trade: it goes deep on Claude Code, and that depth buys things breadth cannot.
because defract is built around the Claude Code lifecycle, it carries persistent codebase memory that compounds with every shipped story — the agents start each task already knowing your conventions and past decisions, instead of re-loading context every run. on a team, that shared, structured memory is the difference between parallel agents that drift apart and parallel agents that stay consistent. if you need to run Codex, Aider, or Gemini side by side, that breadth is exactly where superset is the better fit.
| defract | superset | |
|---|---|---|
| core bet | a structured lifecycle, idea to shipped | maximal parallelism — 10–100+ agents at once |
| structure | story → design → architecture → implementation → review → release | unstructured — you orchestrate the process yourself |
| design stage | visual design artifact — rendered UI reference before any agent starts | none |
| code review | specialist agents (security · refactor · generic); gated merge on sign-off | no built-in review gate — it is a runner, not a pipeline |
| agent support | Claude Code-native (PTY) — deep, with compounding memory | agent-agnostic — Claude Code, Codex, Aider, Gemini CLI, Cursor, OpenCode |
| parallel worktrees | ›yesshared primitive | yes — the headline feature, built for 100+ |
| memory / context | persistent codebase memory — compounds with every shipped story | per-session — context is re-loaded each run |
| environment | dedicated desktop app built around the lifecycle | desktop IDE — editor, chat, in-app browser, port management |
| data handling | local-first — code and PTY transcripts stay on your machineboth local | local — runs on your machine |
| economics | free — bring your own anthropic key, pay anthropic directly | free — bring your own CLI; source-available (Elastic License 2.0) |
| platform | macos (windows · linux in v1) | macos (windows · linux coming soon) |
| availability | open beta — download now | source-available — self-install |
we’ll be direct: if your bottleneck is sheer agent count, superset is built for it in a way defract is not — running 10 to 100+ agents at once is its headline, and it does worktree isolation cleanly at that scale. it is also agent-agnostic: Claude Code, Codex, Aider, Gemini CLI, Cursor, OpenCode all run under one roof, so if you are deliberately multi-vendor, that breadth is real and defract does not match it — defract is Claude Code-native by design. superset ships a mature IDE surface too — editor, chat, in-app browser, port management — for people who want to live inside one window.
the tradeoff superset makes is structure: it optimizes for how many agents you can run, not how reviewable the result is. the visual design stage, the specialist review gate, and the compounding memory are where defract runs a different system — one built for keeping parallel output consistent, especially across a team. if raw fan-out is your need, superset is the better tool; if it is consistency, that is the case for defract.
download the open beta and run one story through the full pipeline — visual design, implementation, review, ship — alongside whatever you run today.