SET
Give it a spec. Get merged features.
Autonomous multi-agent orchestration for Claude Code. We don't prompt — we specify. Every change is planned through OpenSpec, verified by quality gates, and merged automatically.
set-project init --project-type web From spec to merged code — fully autonomous
/set:write-spec for interactive spec generation, set-design-sync to extract Figma tokens.
Multiple Claude agents in isolated git worktrees. Real branches, real merges.
Test, build, E2E, lint, review, spec coverage, smoke. Per-change E2E gates. BDD traceability binds REQ-IDs to tests. Exit codes, not vibes.
3-layer templates + set-compare scoring. 87% structural overlap on micro-web, 83% on minishop. Convention compliance: 100%.
Structured artifacts: proposal → design → spec → tasks → code. No hallucination.
Issue pipeline: detect → investigate → fix → verify. set-harvest scans E2E runs, classifies fixes, adopts them into planning rules. Permanent improvements.
Core stays abstract. Web, voice, fintech — pluggable project types.
Gate failures become planning rules. set-harvest extracts fixes from 30+ runs across 3 projects. Each run is smarter than the last.
Figma Make → set-design-sync → per-change design.md with scope-matched tokens. Each agent gets only the colors, fonts, layouts for its pages.
Real-time monitoring. Step progress (P→I→F→M→A), test artifact gallery, unified logs, gate results. Start orchestration from the browser.
Hook-driven cross-session recall. Agents learn from each other. Shared across worktrees.
3-tier decision model. Auto-restarts crashed orchestrators, remembers spec path across restarts, enriches retries with git context. 30s stall detection.
Multi-agent messaging. Broadcast status, avoid file conflicts, coordinate dependencies.
Waterfall took 8 months. This takes 8 hours.
The principle hasn't changed: output quality depends on input quality. A detailed spec used to mean months of upfront planning. Now it means hours of orchestrated agents building exactly what you described.
You are the product owner. The agents are the dev team. The spec is the sprint backlog. The better the spec, the better the result.
Business requirements, acceptance criteria (WHEN/THEN), technical constraints, dependency listing, seed data conventions.
Framework boilerplate, build config, test setup, linting rules, conventions. You say what. Templates handle how.
40+ tools. One workflow.
Slash commands in Claude Code, CLI tools in your terminal. Everything composes.
Plus: set-new, set-work, set-merge, set-close (worktrees) · /set:status, /set:msg, /set:inbox (team sync) · /set:todo, /set:loop, /set:push (workflow)
We treat determinism as an engineering problem
Run the same spec twice — we measure the structural overlap. 30+ runs, 4 project types, set-compare scores every pair.
| challenge | approach | result |
|---|---|---|
| output divergence | 3-layer template system + set-compare | 87% micro-web · 83% minishop · 4 project types |
| convention compliance | route groups, colocation, naming rules | 100% across all runs |
| quality roulette | 7 programmatic gates (exit codes) | deterministic |
| hallucination | OpenSpec artifacts + acceptance criteria | spec-verified |
| spec drift | coverage tracking + auto-replan | 100% coverage |
| failure recovery | issue pipeline (detect → diagnose → fix) | auto-recovery |
| agent amnesia | hook-driven memory (infrastructure) | 100% capture |
It doesn't retry. It investigates.
Environment broken? Fixed. Bug in SET itself? Fixed — and the fix is permanent. Every failure makes the system better.
The sentinel doesn't blindly retry failed gates. It reads logs, traces root causes, and dispatches targeted fixes. Environment misconfigured? It reconfigures. Dependency conflict? It resolves. Bug in SET's own code? It patches set-core and commits the fix — so the same failure never happens twice.
This is the difference between "retry 3 times and give up" and an actual engineering process. Detect → investigate → fix → verify → learn. Permanent fixes, not temporary workarounds.
Real issue tracker from 30+ orchestration runs. Every resolved issue was fixed autonomously.
Build your own project type
SET ships with a web project type battle-tested across 30+ runs. The real power is building your own.
A real agent session — spec to merged code
Single-agent was the start. Orchestration is the present. Enterprise is preparing.
Systems like SET can do the work of a full development team — given the right spec and properly developed project types. This is the present, not the future.
Don't blame the model. 90% of agent failures are underspecification on our side. SET exists to enforce structure, verify output, and close those gaps.
Enterprise is next. On-premise models, secure multi-tenant — the infrastructure is coming. Every organization should prepare now.
Model providers will build orchestration natively. We welcome that. But we're not waiting.
Build With SET
Open-source and autonomous. Need something custom? We can help.
custom_project_type
We build a ProjectType plugin for your stack and domain. Your rules, your gates, your templates. Pip-installable, works with set-project init.
workshop
Hands-on spec-driven development training. Write specs that produce working apps. Run orchestration, understand gates, build memory. Remote or on-site.
managed_run
Send a spec, get a working app. We run the orchestration, you review the PRs. Quality gates guarantee the output. Ideal for MVPs and proof-of-concepts.
when orchestration gets intense, defend your changes.
arrow keys + space. every change is a ship.