Appearance
Diverge
Divergent ideation, the anti-anchoring counterpart to the orchestration workflows. Linear reasoning locks onto its first answer, and tree-of-thought widens but keeps a shared context so the anchoring rides along every branch. Diverge treats that as an architecture problem: it fans N isolated agent branches, one cognitive frame each, with zero shared context between them, so nothing anchors on anything. Each branch is a pure generator, forbidden to evaluate, and emits raw ideas. Then a focus critic scores them, flags the traps, clusters by underlying approach, and picks the top-K, and a deepen pass sketches each survivor into something a builder could start on.
It reaches for a design, naming, strategy, or fuzzy-debugging problem, anything shaped give-me-several-ways. It runs in session through Claude Code's Workflow tool like the rest of orchestration/, so it needs the ultracode opt in for a live fan out, and it is budget aware, clamping its branch and deepen counts to what is left.
In Practice
Diverge runs in three steps, deterministic frame resolution first, then the fan out, then the render:
1. Resolve the frames with frames.nu, no tokens spent:
nu .claude/workflows/frames.nu select --mode auto --ideas 6 --top 3It prints the run plan as JSON, { mode, ideas, top, frames, need? }. The modes are fixed (the shipped default set), all (every frame), auto (hand the whole catalog to the workflow's triage), or --frames a,b,c for an explicit list that overrides any mode. frames.nu list shows the catalogue, frames.nu dump <id> prints one frame's full vantage.
2. Run the workflow, passing the problem plus that plan in as args:
Workflow({ scriptPath: ".claude/workflows/diverge.workflow.js",
args: { problem: "<the problem>", context: "<optional>", mode: "auto",
frames: <the frames array from step 1>, need: 5, ideas: 6, top: 3 } })It fans one generator per frame (each blind to the others, forbidden to evaluate), runs a single critic that scores, traps, clusters, and picks the top-K, then a deepen pass that sketches each survivor. It returns the bundle.
3. Render the returned bundle with diverge-render.nu:
<bundle-json> | nu .claude/workflows/diverge-render.nu # markdown
nu .claude/workflows/diverge-render.nu --file bundle.json --html --out diverge.html # one self-contained pageThe Pipeline
Four stages, mapped to the workflow's phases. The generator-critic split is mechanical, separate calls with opposing system prompts, not a prompt promise.
frame
One cheap stage that resolves which frames run. In auto mode a triage agent reads the problem and picks the best-fit need frames from the catalog, chosen for varied, non-overlapping, high-yield angles; fixed, all, and explicit --frames runs skip the triage entirely and take the set frames.nu already resolved. The branch count then clamps to the budget before the fan out.
diverge
The genuine barrier-free fan out, one agent() per frame inside a single parallel(). Each generator gets only the problem, any context you passed, that frame's vantage prompt, and a system instruction that forbids it to evaluate, rank, score, compare, or reference any other frame. This is the anti-anchoring linchpin, and it rests on gate G-diverge-1, which proved that two agent() calls inside one parallel() are genuinely context-isolated, neither seeing the other's prompt or output. Each branch returns M short, distinct ideas as schema JSON, and the ideas are flattened to id-addressable rows (<frame>-<n>) so the critic can reference them.
focus
The one place every branch's ideas are needed at once, so it is a real barrier. A single critic agent, running the opposite of a generator's prompt, scores every idea on novelty, viability, and fit (each 0 to 10), flags the traps (seductive-but-broken, each with a one-line reason), clusters ideas that share an underlying approach even across frames, and picks the top-K. A trapped idea can never be picked.
deepen
K parallel sketch agents, one per pick, each expanding its idea into a 4 to 8 sentence how-it-works, the single load-bearing risk, and the first concrete step a builder would take, grounded in that idea. K clamps to the budget, and because picks already exclude the traps, a trapped idea never reaches this stage.
Selection
Three ways a run's frames get chosen, and --frames always wins:
| mode | how the frames are chosen | for |
|---|---|---|
auto | the triage agent reads the problem and picks the best-fit N from the registry | the default, let the problem choose its lenses |
fixed | the default_set taken as-is, no triage call | deterministic, cheap, repeatable runs |
all | every frame in the registry | maximal divergence, the expensive one, budget-warned |
--frames adversary,biology,markets overrides any mode with an explicit list. The frame count N and the deepen count K both clamp to what the budget has left, and an all-mode run warns before it fans out over every frame.
The Frames
The frame set is data, not code, in frames.nuon, the 15 cognitive frames lifted verbatim from UditAkhourii/adhd (MIT, attributed in the file header, the vantages normalised to finn-style). Each frame is one vantage prompt that re-asks the problem from a fixed angle:
hardware-eyes regulator ten-year-old adversary biology logistics game-design markets inversion extreme-zero extreme-infinite remove-assumption speedrunner ant-colony ops-3am
So adversary generates approaches that break the obvious solution then inverts each into an idea, biology transplants a mechanism from immune systems or evolution, extreme-zero gives you no money and one hour and asks for the crudest thing that still works. The default_set for fixed mode is six of them (adversary, inversion, extreme-zero, biology, remove-assumption, ops-3am), a spread that covers attack, negation, minimalism, cross-domain transplant, assumption-breaking, and operability.
The registry is the extension point. A project adds a frame by adding a row (a finn-stack engine-systems or game-feel frame, say), and the workflow never hardcodes one, it always reads the set through frames.nu.
The Bundle
Diverge returns a structured bundle, the contract a caller consumes and render.nu reads, documented in full in bundle-schema.md. One parse, every downstream reads the same shape. Ideas are id-addressable and carry their scores and cluster index; picks, traps, and deepened sketches cite ideas by id, so nothing is duplicated:
{ problem, mode, frames_used, ideas_per_branch, total_ideas,
ideas: [ { id, frame, text, novelty, viability, fit, cluster, trap?: { reason } } ],
clusters: [ { id, label, idea_ids } ],
picks: [ id... ],
traps: [ { idea_id, reason } ],
deepened: [ { idea_id, sketch, risk, first_step } ],
note }A trapped idea keeps its scores and its cluster, it is only held out of picks and deepened, so the reasoning stays inspectable. An unset field is null, never missing, so a consumer never tests for absence, and because the bundle is the workflow's return value, another workflow can call diverge as a sub-step and read it as-is.
The Render
render.nu turns a bundle into a readable doc, markdown by default and one self-contained HTML page on --html. The markdown leads with the picks as expanded sub-sections (sketch, risk, first step), then the clusters as sections with traps flagged inline, then the traps on their own. The HTML is a single file with an inline stylesheet and zero external HTTP references (the find-todos self-contained check), the source owns the tag and the render owns the styling, a trap becoming a caution span and the scores a small badge.
Flags and Notes
--drypreviews without spending, it runs only step 1 (frames.nu select) and shows the chosen frames plus the plan, it never fans out.- budget clamps the branch count and the deepen count to what is left; an
all-mode run over every frame is the expensive one, so it warns first. - composable is the point of the bundle. Another workflow can call diverge as a sub-step (
workflow('diverge', args)), the planner uses it to spread the alternatives before a fork, and the router sends any give-me-several-ways prompt to it. - if
scriptPathis refused, a CRLF workflow file can trip a strict approval gate on the carriage returns; run the same script inline instead, the content is unchanged.
Budget Convention
Like every workflow in the kit, diverge is budget aware. A branch costs roughly one generator agent, so it prices a branch at 15k tokens and clamps the count to budget.remaining():
js
const branchCap = budget.total ? Math.max(2, Math.floor(budget.remaining() / PER_BRANCH)) : InfinityThe clamp bites in two places, the branch count after frame selection and the deepen count before the sketches. With no budget directive set, budget.total is unset and the run takes its full path, the gate only bites once a budget is in play. The clamp arithmetic is proven headless; the live +Nk pass-through is gate G-diverge-2, still partial until a run is exercised under a real directive.
Connects to
- The orchestration workflows are its siblings in
orchestration/, but the job is opposite: they decide how to run a task, diverge generates what to try. It supersedes only the shallowthinking:brainstormfor real divergence, and it is notdebate, whose agents deliberately share context after round one to converge. - It is built to compose. The bundle is why it returns structured data, so the planner can surface candidate approaches before its forks, the router can hand it give-me-several-ways prompts, and atlas can borrow its frames for research angles.
- Installed by the installer as its own part into
.claude/workflows/, six files, the workflow plusframes.nuon,frames.nu,render.nu, the bundle schema, and the/divergecommand, whereframes.nuresolves against the installedframes.nuon.