Workflows

14 built-in workflows and 14 methodologies — opinionated, phase-based recipes with quality gates, all customizable in YAML.

A workflow is a recipe of phases an agent runs to complete a task — plan, implement, test, document, review, ship. A methodology is the matching set of roles, prompts and quality bars it runs with. Excalibur ships 14 workflows and 14 methodologies, and picks the right one from your intent — or you choose explicitly.

The default pipeline

Code-shipping workflows run these phases. Verify (tests) and Document are first-class gates, not afterthoughts:

Plan ─→ Implement ─→ Verify (tests) ─→ Document ─→ Review ─→ Pull request
                          │                │           │
                        gate             gate     adversarial

Document runs before Review on purpose: the review (an adversarial pass that tries to refute the change) covers the docs too, and the PR opens complete — code, tests and docs together.

Phase types: context · plan/spec · agent_work · verify (gate) · document (gate) · review · apply_patch/pr. Phases can be optional, can requireHumanConfirmation, and declare onFailure behavior.

The catalog

Workflow	When to reach for it
Review First	Understand and critique before any change (L0).
Fast Fix	Small, obvious fixes — minimal ceremony.
Standard Feature	The everyday plan → build → test → ship.
Structured Feature	Bigger work needing specs, gates and approvals.
Safe Refactor	Behaviour-preserving change, tests as the net.
Security First	Threat-aware build with a security-review gate.
Migration	Staged, reversible, data-aware changes.
Explore Alternatives	Several approaches in parallel — compare and pick.
Discovery	Decide what to build — or whether to build at all.

…plus human-gated and ask-repo, and a matching methodology for each. List them with excalibur workflows list.

How a workflow is chosen

Excalibur infers intent and proposes a workflow + autonomy, then confirms before running:

excalibur

›migrate the user table to the new schema

intent: migration · workflow: migration · autonomy: L4

→[Enter] run · [m] modify · [c] careful

Override it explicitly — in the shell with a /command, or as a one-shot CLI command:

excalibur run "speed up the report query" --explore      # N candidates, compared
excalibur run "rotate signing keys" --careful            # max caution (L4)
excalibur run "tidy imports" --fast                       # minimal ceremony
excalibur run "add SSO" --structured                      # force structured-feature
excalibur run "…" --workflow security-first               # name a workflow
excalibur workflows list
excalibur workflows explain standard-feature

Explore = rival approaches, side by side. --explore (or /explore) fans out several candidate implementations in parallel (one per worktree), then compares diffs, tests and cost so you pick the winner — or fork a new run from the best.

Orchestration — parallel agents, verified

Bigger work fans out on its own — the planner sizes the shape itself — but you can drive it:

Swarm (swarm · /swarm) — independent subtasks run as parallel agents in isolated git worktrees, then fan in. The merged tree is verified against ground truth (your tests + an adversarial review mesh) before it touches your code; textual conflicts 3-way-merge, a shared budget binds across lanes, and an exhausted lane can self-heal once.
Authored specs — commit a deterministic DAG in .excalibur/orchestrations/<name>.yaml (dependsOn waves, per-step role / when / maxAttempts / outputSchema) and run it with excalibur orchestrate --spec <name> (--resume re-runs only the edited steps).
Chronogram — watch any orchestration as a live wave/DAG timeline (excalibur orchestration, also in the dashboard): pause / resume mid-flight, with a time-travel scrubber to replay it.
Schedule & background — run a task on a cadence (excalibur schedule add "every 2h" "…", or just say "every morning run the tests"), or send it to the background (/bg + /threads) where a supervisor reacts when it finishes.

Customize everything in YAML

Extend a built-in or define your own. Every phase, gate and role is editable:

# .excalibur/workflows/secure-feature.yaml
name: Secure Feature
extends: structured-feature
methodology: security-first
phases:
  - plan
  - implement
  - verify
  - security-review        # added gate
  - document
  - review
approvals:
  - sensitive-paths        # require a human on sensitive files
agents: auto               # 'auto' sizes the swarm; a number caps it

Set defaults per task type so the right workflow is picked automatically:

# .excalibur/config.yaml
workflowDefaults:
  bugfix: fast-fix
  feature: standard-feature
  migration: migration
  ambiguous: discovery

Run excalibur init --full to export the full built-in catalog as editable files. The complete schema (phases, roles, scoring, question packs) lives in Extensions.

Autonomy levels — how far each phase is allowed to go.
Discovery — the decide-before-you-build gate.
Command reference — every workflow command.