Archon

Operator's take

Archon is aimed squarely at the thing that makes AI coding feel like a slot machine: ask the same agent to "fix this bug" twice and you get two different processes — one run plans first, the next skips straight to code and forgets the tests. Archon's bet is that the process shouldn't be left to the model's mood. You write the sequence down once as a workflow, the workflow owns the structure and the validation gates, and the AI only supplies intelligence at the steps where intelligence actually helps. The repo's own framing is the clearest pitch: "Think n8n, but for software development." For anyone who already thinks in no-code automation terms, that analogy does a lot of work — it's a DAG of nodes, some deterministic (run tests, git ops), some AI-driven (plan, review).

Where this gets genuinely interesting for an operator is the fire-and-forget angle. Each workflow run spins up its own isolated git worktree, so you can kick off five fixes in parallel without them stepping on each other, walk away, and come back to finished PRs with review comments waiting. You define a workflow once in .archon/workflows/, commit it to the repo, and it runs identically from the CLI, the web dashboard, Slack, Telegram, or a GitHub webhook — so the same encoded process is portable across your whole team and every surface they work from. That portability plus the 19 prebuilt workflows (fix-a-GitHub-issue, idea-to-PR, multi-agent PR review) means you can get value without authoring anything yourself on day one.

The honest catch: this is a developer's tool wearing automation clothing. The audience that gets the most from it already lives in git, runs a coding agent, and writes YAML comfortably — and it's currently built around Claude Code as its primary assistant. If your "no-code" is Airtable and n8n rather than pull requests, this isn't your lane; Archon automates software development, not business operations. And it's young — a from-scratch rewrite of an earlier project, so expect rough edges and a moving target rather than a settled product.

What it's good at

• Making AI coding repeatable — the workflow defines the phases, validation gates, and artifacts; the AI fills in each step, so the same sequence runs the same way every time.
• Parallel, isolated runs — every workflow run gets its own git worktree, so multiple fixes run at once without conflicts.
• Fire-and-forget execution — kick off a workflow, go do other work, come back to a finished PR with review comments.
• Mixing deterministic and AI steps — compose bash scripts, tests, and git ops (deterministic) with planning, codegen, and review (AI), so the AI only runs where it adds value.
• Portable across surfaces — the same committed YAML workflow runs identically from CLI, web UI, Slack, Telegram, or GitHub.
• Batteries included — ships 19 default workflows (fix-GitHub-issue, idea-to-PR, multi-agent PR review, refactor-safely) you can run or copy and customize.
• Open-source and self-hostable — MIT-licensed, runs on SQLite or PostgreSQL, with opt-out anonymous telemetry.

What it's not

• Not for non-developers — workflows are YAML, the unit of work is a pull request, and setup needs Bun, Claude Code, and the GitHub CLI; this automates software development, not business operations.
• Not assistant-agnostic in practice — it now spans multiple agents (Claude Code, Codex, and more behind one "command layer"), but Claude Code is still the assistant the setup requires, so you're committing to that ecosystem.
• Not a mature product — it's a ground-up rewrite of an earlier Python task-management/RAG tool, so expect a fast-moving target rather than a stable, settled platform.
• Not a hosted service — you self-install the CLI or run the Docker image and maintain it yourself; there's no managed cloud offering.
• Not the same Archon as before — if you came looking for the original Python task-management + RAG project, that's preserved on an archive branch, not what this is now.