# Archon

> Define AI coding workflows as YAML so every run follows the same deterministic steps

- Category: AI Coding / AI SDLC Automation
- Language: TypeScript
- Licence: MIT
- Repository: https://github.com/coleam00/Archon
- Website: https://archon.diy
- Canonical page: https://ai-tldr.dev/tools/archon/
- Updated: 2026-04-10

## In short

Archon is a workflow engine for AI coding agents. You describe your development process — planning, implementation, validation, code review, PR creation — as a YAML workflow, and Archon runs it the same way every time across every project. It sits in the AI SDLC Automation category of the AI Coding tools and is open-source, written in TypeScript and licensed MIT.

## Overview

Archon is a workflow engine for AI coding agents. You describe your development process — planning, implementation, validation, code review, PR creation — as a YAML workflow, and Archon runs it the same way every time across every project. The pitch is a familiar one: what Dockerfiles did for infrastructure and GitHub Actions did for CI, Archon does for AI coding workflows.

The problem it targets is variance. Ask an agent to "fix this bug" and what happens depends on the model: it might skip planning, forget to run the tests, or ignore your PR template. Archon moves that structure out of the prompt and into a file you own. The workflow defines the phases, the validation gates and the artifacts; the model supplies intelligence at each step but does not decide the sequence. Nodes are composable — `bash` nodes run scripts, tests and git operations deterministically, `prompt` nodes call the AI, and `loop` nodes iterate until a condition such as `ALL_TASKS_COMPLETE` or `APPROVED` is met, optionally with a fresh context each iteration or an interactive human-approval pause.

Every workflow run gets its own git worktree, so five fixes can run in parallel without conflicts, and runs are fire-and-forget: start one, come back to a finished PR. Workflows live in `.archon/workflows/` and commit to your repository, so they behave identically whether triggered from the CLI, the web dashboard, Slack, Telegram or GitHub. The current TypeScript engine replaced an earlier Python version focused on task management and RAG, which remains on the `archive/v1-task-management-rag` branch.

## What it does

- Workflows defined as YAML in .archon/workflows/ and committed alongside your code
- Composable node types — deterministic bash nodes, AI prompt nodes, and loops that run until a condition is met
- Every run executes in its own git worktree, so parallel runs never collide
- Interactive approval gates that pause the workflow and wait for a human
- Fresh-context iterations for long implementation loops
- Runs from the CLI, a web dashboard, Slack, Telegram or GitHub with the same definitions
- Guided setup wizard that configures credentials, platform integrations and installs the Archon skill into your projects

## Getting started

There are two paths. The full setup runs a wizard that configures credentials and gives you the web dashboard; the quick install just drops the CLI binary in place if you already have Claude Code. Prerequisites for the full setup are Bun, Claude Code and the GitHub CLI.

1. Install the CLI

   The quick install fetches a standalone binary. On x64 it requires AVX2; older hardware and VMs that mask AVX2 should build from source instead.

```bash
# macOS / Linux
curl -fsSL https://archon.diy/install | bash

# Homebrew
brew install coleam00/archon/archon
```

2. Install on Windows

   The PowerShell installer is the Windows equivalent of the shell script.

```bash
irm https://archon.diy/install.ps1 | iex
```

3. Point Archon at Claude Code

   The compiled binaries do not bundle Claude Code. Install it separately and set CLAUDE_BIN_PATH, or set assistants.claude.claudeBinaryPath in ~/.archon/config.yaml. The Docker image ships Claude Code pre-installed.

```bash
curl -fsSL https://claude.ai/install.sh | bash
export CLAUDE_BIN_PATH="$HOME/.local/bin/claude"
```

4. Write a workflow

   Put a YAML file in .archon/workflows/. Nodes declare dependencies; bash nodes are deterministic, prompt nodes call the AI, and loops iterate until their condition is met.

```yaml
# .archon/workflows/build-feature.yaml
nodes:
  - id: plan
    prompt: "Explore the codebase and create an implementation plan"

  - id: implement
    depends_on: [plan]
    loop:
      prompt: "Read the plan. Implement the next task. Run validation."
      until: ALL_TASKS_COMPLETE
      fresh_context: true

  - id: run-tests
    depends_on: [implement]
    bash: "bun run validate"

  - id: review
    depends_on: [run-tests]
    prompt: "Review all changes against the plan. Fix any issues."

  - id: create-pr
    depends_on: [review]
    prompt: "Push changes and create a pull request"
```

5. Run it

   From inside your project, tell your coding agent to use Archon for the task. It creates an isolated worktree, walks the workflow phases, iterates until tests pass, and hands back a PR link.

## When to use it

- Make agent-driven bug fixes and features follow the same plan → implement → validate → review → PR sequence every time
- Run several agent tasks in parallel on one repository without them stepping on each other's working tree
- Put a human approval gate in the middle of an otherwise autonomous coding run
- Share a team's development process as a committed, reviewable file instead of a prompt everyone copies

## Version history

- 2026-04-10: Archon released as an open-source workflow engine for AI coding agents: YAML-defined workflows with deterministic phases, isolated git worktrees, and composable nodes mixing scripts with AI tasks.