verdent is a strong parallel runner — it plans a task, fans it out across agents in isolated worktrees, and verifies the result. defract is a different bet: a guided lifecycle that carries a story from idea to shipped, with design as a gated stage, agent-reviewed merges, and own-claude economics. built to lower the load in your head.
they overlap on the basics. both defract and verdent plan before they code and run agents in parallel, each in its own git worktree, isolated so they don't collide. verdent is good at that — fast fan-out across tasks, with a verification pass. the difference is scope: verdent optimizes throughput on a task; defract carries the whole path a story takes — design, architecture, review, release — as stages with gates, on your own machine.
verdent plans a task and fans it out across parallel agents, then verifies. defract carries the story further.
scope → design → architecture → implementation → review → release. each is a stage with a gate you sign off on; agents do the work in between. it's not a faster way to run one task — it's the whole path from idea to shipped, held by the tool instead of your head.
verdent has no design phase — it goes from plan to code. defract makes design a gated step.
an agent produces the design, you approve it, and that approved design drives implementation. for anything with a user-facing surface, deciding what you're building before agents build it is the difference between fast output and the right output.
verdent is a hosted product billed by credits. defract runs on your machine.
your PTY transcripts never leave the device, and you bring your own claude — paying anthropic directly, no credit layer or vendor markup in between. it's a stated guarantee, not a setting.
| defract | verdent | |
|---|---|---|
| unit of work | a story shipped to production | a task run by parallel agents |
| structure | guided lifecycle: scope → design → architecture → implementation → review → release | plan mode → parallel execution → automated verification |
| design | a gated lifecycle stage — agent-produced, you approve, it drives implementation | none — goes from plan to code |
| code review | agents review agents (types · lint · tests · architecture · security · ux); merge gated on sign-off | automated verification loop |
| parallel git worktrees | ›yes parity | ›yes |
| where it runs / economics | local-first; transcripts stay on device; bring your own claude (pay anthropic directly) | hosted product; credit-based billing (bring-your-own-key optional) |
| models | claude code (codex · gemini · opencode in v1) | multi-model (claude, gpt, gemini, others) |
| surfaces | macos desktop app (windows · linux in v1) | macos app + vs code + jetbrains |
| availability | open beta — download now | available now |
we'll be straight: verdent is a strong, fast parallel runner with a genuine plan-first discipline, it's multi-model, and it meets you inside vs code and jetbrains as well as its own app — while defract is a macos app, claude-code-first, in open beta. if you want raw parallel throughput across the editors you already use, it's a real pick.
defract is a narrower, more opinionated bet: not the most agents in parallel, but the whole lifecycle around them — a design stage, gated review, and your code staying on your machine. we're asking you to choose the process, not the throughput.
download the open beta. if you've been running parallel agents, we'd love your eyes on the lifecycle.