Flows

A flow is a directory of Python that drives one or more coding agents: which agents, what each is asked, in what order, and when to stop. humanize runs flows and has no opinion about what a good one is — which is why the flows are content rather than product, and why the list below is something you can read, fork, publish and beat.

Eleven of them come with humanize or with the flowverse it fetches — thirteen by name, since official/humanize1 is three phases run one at a time. They are, between them, most of the loop shapes the field has converged on: forget every turn, remember every turn, alternate two agents, let the model decide when it is done, put a reviewer between the rounds.

Every round starts where the last one did: from the task and from whatever the round before it left in the working directory.

Every flow there is

eleven, and humanize 1 is three of them

ships with itchat

One agent, one session, and every line typed between turns is a turn of it.

agents

1 + you

ends on

you stop typing

picked up with

nothing — it keeps none

ships with itralph_loop

A fresh session every round, so nothing carries over but the repository.

agents

1

ends on

a budget in output tokens

picked up with

rounds · output

scored as

flowbench ralph_loop

ships with itstateful_ralph

One session, held for the whole run, re-sent the task every round.

agents

1

ends on

a budget in output tokens

picked up with

rounds · output

scored as

flowbench stateful_ralph

the official flowverseofficial/continue_loop

Sends the task once, then keeps nudging “continue” at the session that heard it.

agents

1

ends on

a budget in output tokens

picked up with

rounds · output

scored as

flowbench continue_loop

the official flowverseofficial/goal

Ralph, with the task set as the agent’s own goal: it decides when a turn is over.

agents

1

ends on

a budget in output tokens

picked up with

rounds · output

scored as

flowbench goal

the official flowverseofficial/fixed_juice_ralph

Ralph with a governor: the effort moves a rung a round to hold an answer to a size.

agents

1

ends on

a budget in output tokens

picked up with

rounds · output · effort

scored as

flowbench fixed_juice_ralph

the official flowverseofficial/flame_chase

Two agents take turns on the same task, each reading the repository rather than a history.

agents

2

ends on

a budget the pair spend between them

picked up with

turn · rounds · output

scored as

flowbench flame_chase

the official flowverseofficial/rlar

The actor remembers and the reviewer must not. The review is the actor’s next prompt.

agents

actor · reviewer

ends on

the reviewer agreeing the work is done

picked up with

rounds · the review nobody acted on

scored as

flowbench rlar

the official flowverseofficial/humanize1

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

agents

1, then 2, then 2 + you

ends on

--max rounds, for the loop of the three

picked up with

the directory the loop is in, and its round

the official flowverseofficial/parallel_flame_chase

One coordinator plans three isolated lanes, then leaves; six actors alternate and coordinate by report.

agents

7

ends on

the lanes running out of work, or you

picked up with

the plan, the snapshots, whose turn each lane is on

the official flowverseofficial/parallel_flame_chase_mission

The same three lanes, with a fresh coordinator returning to audit outcomes, stalls and deadlines.

agents

7

ends on

the coordinator adjudicating the last mission, or you

picked up with

the missions, the audits, and everything the base flow keeps

Picking one

The question a flow answers is what does the agent see at the start of a round, and there are only a few honest answers.

If you want	Reach for
To talk to an agent, with no loop at all	chat
A long unattended run that cannot poison itself with its own context	ralph_loop
A long run where the agent has to remember what it tried	stateful_ralph, official/continue_loop
The model, rather than your loop, to decide a turn is not over	official/goal
Each round to cost about the same	official/fixed_juice_ralph
Two agents to check each other by working on the same tree	official/flame_chase
A reviewer that reads the work and writes the next prompt	official/rlar
A plan agreed first, then built under review	official/humanize1
Three streams of work at once, only one of them touching your tree	official/parallel_flame_chase

Seven of them name a FlowBench loop in their own docstring, written against this API so that comparing one method against another is a flag rather than a reimplementation.

Running one

-f takes the flow and -a takes one agent per agent the flow wants, in the order it wants them:

hmz exec -f official/rlar \
    -a claude/claude-opus-5:high -a codex/gpt-5.6-sol:high "$(cat TASK.md)"

Without -f the terminal interface opens on chat, and /flow changes it. A flow that takes settings takes them from a YAML file with -c, and /config is the same fields at the prompt:

hmz exec -f ralph_loop -c budget.yaml -a claude/claude-opus-5:high "$(cat TASK.md)"

The whole of it is in Calling flows and the CLI reference.

What ends a loop

A loop with nothing to stop it runs until somebody stops it, which is a bill nobody agreed to and a week of rounds nobody read. So every loop here that has no stopping condition of its own takes a budget, in millions of output tokens:

budget: 25    # millions of output tokens; 0 goes on until it is stopped

Ten million by default. Output rather than every kind, because output is what a model is asked to produce and the only kind a loop of its own accord grows. The spend is kept in the flow's state, so a loop restarted forty times still has one budget between the forty.

The flows that end themselves instead: chat ends when you stop typing, official/rlar when its reviewer agrees the work is done, and official/humanize1's loop on --max rounds.

Where they come from

builtin	the three in the package: chat, ralph_loop, stateful_ralph
official	humanfia/flowverse, fetched the first time somebody wants what is in it
local · user	.humanize/flows/ here, and ~/.humanize/flows/ everywhere

Any git repository with a flows/ directory in it is a flowverse, and adding one offers its flows by name on every machine you add it to. Flowverses is how, and Writing a flow is how to write one worth publishing.

Adding a flowverse is trusting that repository with this machine

A flow is Python, and reading one means running it: listing what a flowverse holds imports every file in its flows/. Add the ones you would clone and run. Every flow here also runs its agents with permission prompts disabled, and nothing turns them back on — read Security first.