Your process,
across projects, teams, and agents.

Give your agents
a workflow, not
just a prompt.

Open source · local first · no account

ww gives your development process an explicit runtime. Your agent follows the steps; ww runs automation, checks the result, and saves progress for the next session. Start with a setup shaped by your repository, or define your own.

Install in two commands GitHub & docs

Works with the agent you already use — Claude Code, Codex, Gemini, Cursor, and more.

the shape of a task

01Define

Describe your process in ww.yaml.

YAML

02Execute

Agents do the work; ww runs configured automation.

RUN

03Resume

Pick up with task state and artifacts intact.

STATE

Human-readable and inspectable

Not a method. A runtime for yours.

Your process. Your tools.
Any agent.

ww ships no development method. Bring your own process and skills; it adds reusable rules, automated checks, and durable handoffs.

01 · Human-readable rules

Write rules once.
Check every change.

Write rules in plain language. An agent turns them into reusable checks where possible. ww runs those checks automatically; a verifier reasons through the rules that need judgment.

Review and approve proposed checks. Scope rules to relevant changes, and see how often they apply or fail.

Explore rules and checks

A rule in your own words

“Production JavaScript must not call console.log.”

Agent prepares a check · you approve it

Every relevant changeww checks changed JavaScript for console.log callsA script checks the code; the agent doesn’t have to remember.

When a check isn’t practical

A verifier evaluates the change against the written rule.

02 · Project-aware setup

Start with the way you work.

The setup skill learns your repository’s commands and conventions, then proposes a minimal workflow. Choose Express or Guided setup and review it before applying.

Claude Code · skills

> /ww-setup

# Or run the setup skills individually
> /ww-learn-project
> /ww-suggest

03 · Durable progress

Pick up with the evidence.

Task state, results, and artifacts survive the session. Resume in the same local workspace with a clear next step and the previous work available to inspect.

Plan RecordedImplementation RecordedReview Next assignment

04 · Interactive by design

Stay in the conversation.

Talk directly with your agent throughout the work: clarify a requirement, review a result, or change direction. Use one session or delegated workers; ww keeps each assignment and handoff explicit.

YouClarify & reviewAgentWork & discusswwChecks & state

05 · Accountable collections

Keep every finding accounted for.

Handle related review comments or test cases together. Each item keeps its own outcome; the collection cannot finish until every item is resolved and reported.

Every item resolvedEvery outcome reportedThen the workflow continues

Small changes can stay simple: your agent does the work and registers the summary and commits afterward with record. Use a workflow when the development task benefits from one; ordinary questions and read-only investigations stay in conversation.

A workflow, in a few lines

Write the process
once. Run it clearly.

Plan a feature, implement it, run checks, review the result, document the change. You write the left-hand side once. Your agent gets the right-hand side, one step at a time, until the workflow is done.

See more examples

ww.yaml

workflows:
  - name: feature
    description: Ship a small change end to end.
    steps:
      - plan: Break the feature into small steps.
      - develop: Implement the feature.
      - review: Check the implementation.
      - name: build
        shell: 'npm run build'
      - document: Update relevant docs.

Plain YAMLhuman-readable by design

what your agent is handed, one step at a time

./ww next FEAT-42 --role manager

ww output

# FEAT-42 · feature

## Manager and worker: perform `develop`

### Task requirements
Add retry handling to the upload client.

### Previous step result
The plan step left this summary for you:
> Backoff helper, then wire it into send(), then tests.

### Work instruction
Implement the feature.

### Worker completion command
./ww complete FEAT-42 --role worker \
  --artifact="<whole result in Markdown>" \
  --summary="<one or two sentences>"

Every response ends with the next commandno guessing what comes next

Comparison

Three ways to run
a coding agent.

Most tools in this space are one of three shapes, and the shape says more about fit than any feature list.

01 · SKILLS INSIDE THE AGENT

A method as prompts

you ⇄ agent, reading a skill

State: files the agent writes
Checks: the agent, when told to
Between steps: the same chat, you type the next command

Superpowers, BMAD, OpenSpec, Spec Kit’s skills

02 · AN ENGINE OUTSIDE THE AGENT

A program that launches agents

engine → agent → agent → agent

State: the engine’s run files
Checks: the engine’s shell steps
Between steps: a new agent session; a gate may ask you

Spec Kit’s workflow engine, scripts around headless mode

03 · A RUNTIME DRIVEN BY THE AGENT

ww

you ⇄ agent ⇄ ww

State: ww’s task record
Checks: ww runs them itself
Between steps: ww hands the session or delegated worker its next assignment

No method shipped; the process is yours to write

Not either / or

They combine.

A skill is a step to ww. Mix Spec Kit, BMAD, or your own, and add saved state, review, remediation, and automated tests to the process.

Install the named skills in your agent first, and adapt the test command to your project.

ww.yaml

Spec Kit and BMAD inside ww

workflows:
- name: feature
  steps:
    - bmad-product-brief: ~
      kind: skill
    - speckit-specify: ~
      kind: skill
    - bmad-architecture: ~
      kind: skill
    - speckit-plan: ~
      kind: skill
    - speckit-implement: ~
      kind: skill
    - bmad-code-review: ~
      kind: skill
    - fix: Address every finding and verify the result.
      artifact_from: bmad-code-review
    - tests: ~
      argv: [pytest, -q]
      idempotent: true

Their method, your processww runs the tests and keeps the record

See the side-by-side

Side-by-side facts about ww and related tools
Tool	Ships a method	Runs where	State & checks	Human in the loop
Spec Kit skills	Constitution → spec → plan → tasks	In the agent’s chat, as skills	Markdown in `specs/`; checkboxes in `tasks.md`; the agent runs tests	Between commands
Spec Kit workflow engine	The same, as YAML	Terminal or CI; a headless agent per step	Run state on disk; `shell` steps; exit codes from the agent	Terminal gate, then `resume`
BMAD agent roles	Agile roles: briefs, specs, architecture	In the agent’s chat, as skills or plugins	Documents; the agent runs checks	In the chat
Superpowers skills library	Brainstorm → design → plan → TDD → review	In the agent’s chat; 16+ agents	Design doc and task plan; the agent runs tests	Brainstorming questions; design sign-off
OpenSpec change proposals	Propose → specs and tasks → archive	In the agent’s chat; 30+ tools; a CLI manages `openspec/`	`openspec/` specs, changes, archive; `verify` reads code against the spec	Proposal review before code
Agent built-ins agent’s hooks & subagents	None	One agent session	Session-bound; hooks run commands on events	In the chat
ww runtime	None; you write your own	A CLI the agent drives; any agent	Durable task state; ww runs configured checks and commits, gates completion, and supports explicit recovery	In the chat, recorded; steps can offer choices

Use single for one session performing the work, or auto for manager-led delegation. In Git projects, runs normally pin configuration to a committed revision, so switching branches in the primary checkout does not change an active task’s setup. State remains local to your machine.

Get started

Two commands,
then ask your agent.

01
Install the CLI

Python 3.10+ and pipx, on macOS, Linux, or WSL. Install the public beta from PyPI.
terminal
```
pipx install ww-agentic-workflows
```
Upgrade with ww-agentic-workflows upgrade. For unreleased changes or contributing, see editable development installs.
02
Initialize your project

Run it in your repository. It writes ww.yaml, ww.json, a ./ww launcher, and the instructions your agents read.
terminal
```
cd your-project
ww-agentic-workflows init
```
03

Shape the setup, then ask

Ask your agent to run ww-setup. Express setup derives defaults from your repository; Guided setup asks about your process. Review the proposal before applying it, or write your own ww.yaml. Then ask for work as usual.

“Implement retry handling in the upload client. Use ww.”

Take a closer look

Start with what
you need.

REPOSITORY & GETTING STARTEDGitHub + documentation CAPABILITIESAll features WORKFLOWS TO ADAPTTested examples BEFORE YOU UPGRADEChangelog INSTALLATION CHANNELSReleases and development builds CONFIGURATION REFERENCEWorkflow specification WHAT IT DOES NOT DO YETKnown limitations

Give your agents a workflow, not just a prompt.

Your process. Your tools.Any agent.

Write rules once.Check every change.

Start with the way you work.

Pick up with the evidence.

Stay in the conversation.

Keep every finding accounted for.

Write the processonce. Run it clearly.

Three ways to runa coding agent.

A method as prompts

A program that launches agents

ww

They combine.

Two commands,then ask your agent.

Install the CLI

Initialize your project

Shape the setup, then ask

Start with whatyou need.