Flows

A flow is a loop around coding agents: which agents it drives, what each is asked, and when it stops. Every one here runs on Humanize. Pick the one that fits your job, give each of its roles an agent, and set a budget.

What do you want to do?

01Talk

You and one agent, turn for turn.

chatships with humanize

One agent, one conversation: every line you type back is its next turn.

-a

assistant

ends

you send nothing back, so under hmz exec after one turn

--resume

starts afresh

02One agent, looping

One agent takes round after round on the same task.

ralph_loopships with humanize

The task again every round, in a fresh session, so only the repository carries over.

-a

agent

ends

3 rounds in a row that answer nothing

--resume

the round count

stateful_ralphships with humanize

The task again every round, in one session that remembers every round before.

-a

agent

ends

3 rounds in a row that answer nothing

--resume

the round count, not the session

continue_loopships with humanize

The task once, then “continue” to the same session, round after round.

-a

agent

ends

3 failed turns in a row

--resume

the round count, not the session

goalships with humanize

The task set as the agent’s own /goal: the model keeps going until it says the goal is met.

-a

worker

ends

the model says the goal is met

--resume

starts afresh

03A relay

Two agents hand the same tree back and forth.

flame_chaseships with humanize

Two agents take turns on the same task, each in a fresh session, passing only the tree.

-a

first_chaser · second_chaser

ends

3 failed turns in a row

--resume

whose turn is next, and the round count

fixed_interrupt_flame_chaseflowverse · v0.1.1

flame_chase on a clock: a trusted evaluator hands the tree over after every k accepted experiments, and one blind review picks the winner.

-a

first_chaser · second_chaser

ends

the wall clock, after one final review

--resume

starts afresh

04A loop with a cleaner

A loop, and a cleaner that distills the tree into one commit every few turns.

agent_cleanup:ralph_loopflowverse · v0.1.1

ralph_loop, plus a cleaner that distills the tree into one commit every few turns.

-a

agent · cleaner

ends

3 turns in a row that come to nothing

--resume

the turn count and the epochs

agent_cleanup:flame_chaseflowverse · v0.1.1

flame_chase, with the same cleaner working between the two chasers.

-a

first_chaser · second_chaser · cleaner

ends

3 turns in a row that come to nothing

--resume

the turn count and the epochs

05Maker and checker

One agent makes, and a fresh one, which never saw it made, judges it.

rlarships with humanize

An actor works in one session; a fresh reviewer reads the work and writes its next prompt.

-a

actor · reviewer

ends

the reviewer says the task is done

--resume

the last review, and the round count

humanize1:<phase>gen-idea · gen-plan · rlcrflowverse · v0.1.1

PolyArch/humanize as three flows: an idea, a plan both sides agreed on, and a build under review.

-a

drafter · planner, analyst · builder, reviewer

ends

each phase on its own; rlcr when the reviewer finds nothing left, or after max rounds

--resume

rlcr only: its loop and round

aotflowverse · v0.1.1

Writes a flow from your description, and lands it once it loads, runs on fakes and passes a critic.

-a

writer · critic

ends

the flow lands, or the repairs run out

--resume

starts afresh

06Lanes at once

Several workspaces, each with agents of its own, at the same time.

parallel_flame_chaseflowverse · v0.1.3

A coordinator plans three lanes once; lane 1 writes your tree, lanes 2 and 3 work on copies.

-a

coordinator · six lane actors

ends

nothing but the budget, or you

--resume

the plan, the copies, the reports, whose turn each lane is on

parallel_flame_chase:git_prflowverse · v0.1.3

Three lanes, each with a clone and pull requests; main moves only for a measured improvement.

-a

orchestrator · six lane actors

ends

nothing but the budget, or you

--resume

the central repository, the receipts, the reports

07Divide and conquer

The task splits into parts, and each part runs the same line.

recursive_lean_proverflowverse · v0.1.2

A Lean theorem, split into lemmas that are each planned, proved and formalized in a worktree of their own.

-a

worker · reviewer

ends

the root theorem is proved, or refused

--resume

the lemmas proved so far, their branches and the wiki

Every run also stops when its budget is spent. Only chat may run without one.

Reading the diagrams

Every flow's page plays a simulated run of it, and every one is drawn with the same few marks. A mark means one thing, in every diagram:

An agent, one lane per role. Its colour says what the role is: does the work , takes turns with it , reads and judges , plans or cleans .

You, a ring with a person, and a program, a square: humanize or your own script, with no model in it.

A new session: the spark on the left edge. The flow opened a session for this turn, so it knows only its prompt and what is on disk.

A held session: a thread from the turn before. The same session takes another turn and remembers; the thread thickens as its context grows.

What a turn does: works, reads, plans, or runs. An agent's turn is a bar, yours is a bubble, a program's is a box.

A pass from one turn to the next. Solid, with a round comet: words, in the next prompt. Dotted, with a square one: files, left in the tree, and nothing said.

A workspace: the plate under the lanes that work in it, named: your repository, a copy, a clone, a worktree.

Lanes at once: workspaces fanned out in depth, the camera craning up to show them running side by side.

Another flow, called: a turn drawn twice, one outline inside the other, with the flow it runs.

The loop: a dashed arc back under the lanes, to where the next round starts, and what repeats.

The budget: a bar that fills only while a model works. Every flow but chat runs under one.

The finish: a post at the right with every way the run ends. The one the run reaches lights up in its own colour.

The camera follows the run: it closes in on each turn as it starts, cranes up while lanes run at once, drops a level where the work splits, and pulls back for the loop and the finish. Pause it, step a moment at a time, or drag the bar. With reduced motion set, the whole run is drawn at rest instead.

The loops, side by side

Most of these flows differ in one thing: what an agent has in front of it when a round starts. Play them one after another and watch for the spark of a new session against the thread of a held one:

simulated

The whole run, at rest. Step through it with the buttons, or drag the bar.

Every round starts from the task and from whatever the round before it left in the working directory — never from what it said.

The run, turn by turn

1. agent — the task; a session opened for this turn; hands agent in the tree: the repository
2. agent — the task; a session opened for this turn; hands agent in the tree: the repository
3. agent — the task; a session opened for this turn; hands agent in the tree: the repository
4. agent — the task; a session opened for this turn

Then round again: nothing carries over but the repository.

It ends when the budget runs out, or 3 rounds in a row answer nothing.

These six are the loops FlowBench scores, under the same names, so a result there tells you which flow to reach for here. All six ship with humanize, beside chat, so they run on a fresh install with nothing installed.

Running one

At the prompt, $ and a flow's name start it on the rest of the line. On the command line, the same run is hmz exec:

at the prompt

❯ $rlar add undo and redo to the editor

hmz exec

hmz exec -f rlar \
    -a actor=claude/claude-opus-5:high -a reviewer=codex/gpt-5.6-sol:high \
    -p budget.duration=6h,budget.cost=60 "$(cat TASK.md)"

The first time you start a flow at the prompt, it asks for an agent for each role, the flow's params and a budget, then remembers them for this project. /flow changes them later.

On the command line	What it says
-f rlar	the flow, by the name on its card
-a actor=claude/claude-opus-5:high	the agent for one role, as role=CLI[@PROVIDER]/MODEL[:EFFORT]. Every flow's page lists its roles
-p max=20	a param, for a flow that takes some
-p budget.duration=6h,budget.cost=60	the budget. Every flow but chat needs one
--resume	pick up this flow's newest run in this directory

Two things never take a flag: the human role, which is you, and workspace, the directory the agents work in, which is wherever you start the run. So no flow here takes an -e. Every flag is in the CLI reference.

Every other flow is installed first

chat and the six loops above ship with humanize. Any other flow runs once it is installed from a flowverse; until then hmz exec refuses it as not installed. Where flows come from says how to install one.

Agents act without asking

No flow puts an agent's command or edit to you for approval. Each role may do what its flow declares, which for most is: change the working directory, run commands, commit. Run a flow only where you would accept that, and read Security first.

What ends a run

• The budget. Whichever of duration, cost and output_tokens runs out first stops the run, and hmz exec exits 0. See Every run has a budget.
• The flow itself. Most flows also end on their own: a reviewer agrees, a goal is met, or three rounds in a row fail or come back empty. Each card says when.
• You. /stop at the prompt, or ctrl+c under hmz exec. See Stopping a run.

A flow whose card says what --resume keeps carries on from there, under a fresh budget. See Picking a run up.

Where flows come from

You type	The flow is
ralph_loop	built into humanize: chat, ralph_loop, goal, flame_chase, stateful_ralph, continue_loop and rlar
parallel_flame_chase	one of humanfia's you installed from humanize's official flowverse, humanfia/flowverse
alice/review	one of somebody else's you installed from it, listed under its author's GitHub user
@theirs/review	one you installed from a flowverse you added
@local/scheduler	one of this project's, in .hmz/flows/
@user/scheduler	one of yours, in ~/.hmz/flows/

A flowverse is an index of flows: each release of a flow is a manifest naming the repository it lives in and the commit it is. Every flow on these pages that is not built in lives in a repository of its own and runs once you install it: in /flow, go to Flowverses → official and install the flow from there. Writing a flow is how to make your own, and Flowverses is how to publish one.

Installing a flow trusts its repository with this machine

A flow is Python, and once it is installed humanize imports it whenever it lists flows. Install only the ones you would install as a package.