skip to content

Clankers are very smart, but…

Clankers are great at thinking and planning, but not at long-running execution.

HyperClank breaks work down into clanker-sized chunks. No LLM in the loop at the top level, every clanker gets a fresh context.

Create a plan, any way you like. HyperClank will read it and…

Text selection and clipboard copy in the terminal UI.
⨝ Drag to Select and Copy in the Monitor (July 5, 2026)
Text selection and clipboard copy in the terminal UI.

Plan milestones

HyperClank sizes up your plan. If it's a big one, it gets broken into milestones.

gantry plan.md
  • Milestone Planner write-milestones.md

    Splits the plan into substantial independently-buildable parts. Writes one brief per milestone. Re-plans when HyperClank observes scoped plan-file changes.

Plan

HyperClank breaks every milestone into sprints. It also sets up a test runner and an environment briefing which are used throughout the job.

  • Environment Briefer write-environment.md

    Writes a briefing on tooling and project structure which every subsequent clanker working on the milestone reads.

  • Sprint Planner write-sprints.md

    Splits a milestone into coherent pieces of work a clanker can finish in one session. Runs declared handler rounds after observed plan-file changes.

  • Tester write-gate.md

    Writes bin/gate, the pass/fail tests HyperClank runs after every clanker action.

Build

A fresh clanker builds each sprint, another clanker reviews it. HyperClank runs the tests after each clanker, and if they fail, a clanker is launched to fix the issue.

  • Builder execute.md

    Implements a sprint. If something in the plan seems impossible, issues an alert rather than improvise.

  • Reviewer review.md

    Reviews a builder's diff against the source plan, applies safe improvements, and expresses future-work changes as scoped plan-file edits.

  • when the tests fail

  • Fixer fix.md

    Makes small changes that make failing tests pass, never changes tests or expands scope.

  • Investigator investigate.md

    When a fix is not successful (tests still fail), diagnoses the failure and writes a report for the human operator.

Review

Once a milestone is complete, HyperClank reviews it and, if necessary, re-plans the remainder of the work.

  • Milestone Reviewer review.md

    Reads a whole completed milestone against the source plan. Scoped future-plan edits are observed and routed to the declared re-planning handler.

Merge

Every HyperClank job takes place in its own git worktree in a sandbox. HyperClank does its own git operations, without using an LLM: it integrates master's tip into the run branch inside the worktree, runs the tests, and merges back with --no-ff. Launches a clanker only if there is a merge conflict.

  • when main has moved under a long run

  • Conflict Resolver

    HyperClank's only git-running clanker. Only launches when upstream master has changed during the run. It integrates main's tip and resolves the conflict inside the throwaway worktree, then hands back to HyperClank to re-run the tests. If it can't be made clean with passing tests, HyperClank restores main untouched and stops.

Loop

HyperClank can also loop. The whole machinery above, repeated until a set goal is reached.

gantry --loop goal.md

HyperClank also supports a simpler form of loop, without planning, closer to a classic Ralph Loop.

gantry --ralph prompt.md

Map

The same careful job, fanned out over a list — one unit per row, each built and merged on its own.

gantry --map items.md

HyperClank turns each row of your spec into an isolated unit with its own worktree, so none waits on another.

Every unit runs the same execute → test → review pipeline a sprint does, with HyperClank running the tests itself.

  • Builder execute.md

    Builds one unit — the same builder a normal HyperClank job uses.

  • Reviewer review.md

    Reviews the unit's diff, applies safe fixes, flags anything affecting the rest of the work.

Each unit carries a skip-test, so a resumed run rebuilds only what isn't done — and gantry merge can land the finished units mid-run.

  • Why Gantry is licensed under PolyForm Internal Use

    Gantry is closed-source source-available commercial software. If you buy Gantry you also get the full source code and you can run it, or modified versions of it, for your own internal use, including for commercial purposes, without time limit.

  • Pushing on a Load-Bearing Seam

    LLMs have stopped saying delve all the time, but present-day models have their own linguistic affectations. Instead of just being annoyed by them, I started saving examples in a file.