Appearance

parallel_flame_chase:git_pr ​

Chase three leads at once, the way a team works a repository: every lane has a clone of its own and opens pull requests, and a pull request reaches main only when a measurement shows it is better. There is no reviewer. Its setup is fixed to the one that did best in a twelve-hour experiment.

flowverse v0.1.3

In hmz, open /flow → Flowverses → official and install parallel_flame_chase, which brings parallel_flame_chase with it. Or run the release without installing anything: 

hmz exec -f 'git+https://github.com/humanfia/parallel-flame-chase-flow@v0.1.3#parallel_flame_chase:git_pr' …
release
v0.1.3 · commit f93127f
earlier
v0.1.2 · v0.1.1 · v0.1.0
licence
Apache-2.0

Read from humanfia/flowverse when this site was built.

text
❯ $parallel_flame_chase:git_pr get the solver under 10 s on every benchmark in bench/
sh
hmz exec -f parallel_flame_chase:git_pr \
    -a orchestrator=codex/gpt-5.6-sol:max \
    -a lane_1_actor_a=codex/gpt-5.6-sol:max,lane_1_actor_b=claude/claude-opus-5:max \
    -a lane_2_actor_a=claude/claude-opus-5:max,lane_2_actor_b=codex/gpt-5.6-sol:max \
    -a lane_3_actor_a=claude/claude-opus-5:max,lane_3_actor_b=codex/gpt-5.6-sol:max \
    -p budget.duration=12h,budget.cost=500 "$(cat TASK.md)"
parallel_flame_chase:git_prsimulated

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

No reviewer: a pull request reaches main when its receipt shows an improvement, and the repository refuses any main that is not the tree that was measured.

The run, turn by turn
  1. orchestrator — plans three lanes; a session opened for this turn; hands lane_1_actor_a as words: lane 1; hands lane_2_actor_a as words: lane 2; hands lane_3_actor_a as words: lane 3
  2. lane_1_actor_a — a turn; a session opened for this turn; hands lane_1_actor_b in the tree: the clone
  3. lane_2_actor_a — a turn; a session opened for this turn; hands lane_2_actor_b in the tree: the clone
  4. lane_3_actor_a — a turn; a session opened for this turn; hands lane_3_actor_b in the tree: the clone
  5. lane_1_actor_b — a turn; a session opened for this turn
  6. lane_2_actor_b — pfc evaluate, PR ready; a session opened for this turn; hands main in the tree: a PR and its receipt
  7. lane_3_actor_b — a turn; a session opened for this turn
  8. main — beats main: merged; no turn of a model; hands lane_1_actor_a as words: pr_merged; hands lane_3_actor_a as words: pr_merged
  9. lane_1_actor_a — on the new main; a session opened for this turn
  10. lane_3_actor_a — on the new main; a session opened for this turn

Then round again: each lane alternates a and b; main moves only for a measured improvement.

It ends when the budget runs out, or you stop it.

When to use it ​

When the task has a number to beat, such as a benchmark, a score or a size, and a command that measures it. Nothing here asks a model whether a change is good: the measurement decides. If the task has no such number, use parallel_flame_chase, where one lane writes your tree and the other two report to it.

How a change reaches main ​

  1. A lane may keep many drafts, but only one pull request ready at a time. A ready pull request is frozen, and a newer one from the same lane replaces it.
  2. The lane measures it with pfc evaluate -- <command>, which runs your evaluator on a clean tree and keeps a receipt of the result that cannot be changed.
  3. The best candidate is merged only if its receipt improves on main. The repository itself refuses a main that is not exactly the tree that was measured.

What lanes learn from each other is their reports, and the flow's own reports of what was merged and what was refused.

Roles and params ​

RoleWhat it isHow it is filled
orchestratoragent, required-a orchestrator=…Plans the three lanes, once.
lane_1_actor_a · lane_1_actor_bagent, required-a lane_1_actor_a=…,lane_1_actor_b=…Lane 1, taking turns in fresh sessions, in a clone of its own.
lane_2_actor_a · lane_2_actor_bagent, required-a lane_2_actor_a=…,lane_2_actor_b=…Lane 2, the same.
lane_3_actor_a · lane_3_actor_bagent, required-a lane_3_actor_a=…,lane_3_actor_b=…Lane 3, the same.
humanyoufilled by humanize; no -aAsked only to confirm copying a very large workspace.
workspaceenvironment, localthe directory you start in; no -eYour tree, from which the run makes a central repository and a clone per lane.

Each agent role takes one -a role=CLI[@PROVIDER]/MODEL[:EFFORT]; several roles may share one -a, comma-separated. There is no -e to give: workspace is a local environment, the directory you start the run in, and an -e naming it is refused. See Command-line specs.

Any backend can fill any role. The lane actors may also write outside their clone, which is how they push to the run's central repository.

ParamDefault
rest_seconds1.0Seconds the scheduler rests between passes, 0.05 to 60.
resume_modeautoauto picks up a compatible earlier run; fresh starts another.
confirm_large_workspace_copiesfalseAsk before making the copies of a very large workspace. Under hmz exec nobody answers, so the run does not start.
workspace_file_warning_threshold5000Files that make a workspace very large.
workspace_copy_warning_threshold_bytes1073741824Bytes of copies that make it very large (1 GiB): the lanes' clones, the planning tree and the git objects.

Five more params are fixed, so that a launch cannot turn the measured setup into a different one: git_pr_enabled is true, and global_knowledge_enabled, experiment_memory_enabled, token_efficient_enabled and main_update_monitor_enabled are false.

What ends it ​

The budget, or you. The lanes go on for as long as the run does, so give it budget.duration. When it runs out, the turns under way finish and are recorded, and the run stops.

Picking it up ​

--resume picks up the central repository, the receipts, the artifacts and the reports, and carries on. -p resume_mode=fresh starts another run instead. See Picking a run up.

Leave your source tree alone while a run holds it. Only one run may hold a source tree at a time, whether of this flow or of parallel_flame_chase: a second one refuses to start.

See also ​