engines
the raw coding agent in your terminal — fast, flexible, scriptable. every other flavor on this list builds on top of one of these, or competes with what's built on top.
the strongest coding agent there is, one prompt away.
everything around the code — design, review, release live in your head, not in the tool.
agentic editors
ai in the place you already write code — autocomplete, codebase context, an agent inside the editor. you stay in the loop, typing, driving one session at a time.
a dramatically faster loop from keystroke to working code.
it speeds up writing code. the build around the code — scope, design, review, ship — stays manual.
spec-first ides
no agent writes a line until there's a requirements doc, a design artifact, and a task list. discipline before code — and that discipline is real.
agents that build what you meant, because you wrote it down first.
the spec is the start of the lifecycle. what happens after it — parallel work, review, release — is on you.
skills & governance frameworks
guardrails bolted onto the engine — composable skills, role-based governance, test-driven habits. the cli reasons inside rules you set. free, and often excellent.
discipline inside the terminal, at zero cost.
still one terminal, one session. it bounds the agent's decisions — it doesn't run the process around them.
native agent teams
parallelism built into the engine itself — the vendor spawns and coordinates a fleet of agents for you, whether in your terminal or their cloud. free, native, and the new floor every tool above has to clear.
parallel agents at no extra cost, no extra install.
raw coordination. no lifecycle, no gates — you still drive every step yourself.
parallel runners
fan agents out across isolated git worktrees, keep them from colliding, collect the diffs. the axis they scale is quantity — how many agents you can run at once.
throughput without babysitting — an army of agents, cleanly isolated.
they scale how many agents run, not how structured the work is. every diff still lands on your desk.
visual canvases
a board of agent sessions and editors you arrange yourself — the multi-agent overview a terminal never gives you, laid out in space instead of tabs.
sight — everything your agents are doing, on one screen.
the canvas is freeform. the process is still yours to invent, session by session.
lifecycle orchestrators
the process itself — one story carried idea-to-shipped through the full pipeline: story › design › architecture › implementation › review › release, with agents doing the work between the steps.
parallel agents in isolated worktrees, a built-in visual design stage, agents reviewing agents, and memory that compounds every time you ship.
it's opinionated and local-first — runs on your claude, nothing leaves the device. devin and factory chase full autonomy; defract keeps you on the gates, signing off on intent, not 800-line diffs.