Hyperflow

The chain

Start anywhere. Auto-advance forward.

Chain-starting skills auto-advance through the rest of the chain. Skip to any entry point — the orchestrator picks up and runs forward.

Start with a rough idea: amplify rewrites it into the strongest prompt, then hands off into the chain. spec → scope → dispatch auto-chains — enter at spec for design-first work, at scope when the approach is clear, at dispatch when a task file already exists. audit and deploy gates fire at the end, batched into one ask. (scaffold is a one-time project setup, run once per repo.)

The thinking / worker split

The whole product in one idea.

Expensive thinking models handle what they're best at: planning, questioning, and reviewing. Fast worker models handle what they're best at: writing code. The split is structural — not a setting.

The core loop

Every worker output reviewed by a thinking-tier model. No exceptions.

Independent sub-tasks fan out in parallel — three files with no shared state means three workers in one batch. Each parallel worker feeds its own thinking-tier reviewer before the batch advances. Reviews collapse synchronously at the end of each batch; no output reaches the next batch unreviewed.

Per-batch worker-tier reviewers handle L1–L2 spot-checks on small diffs. The final integration reviewer (thinking-tier) runs once at the end over the cumulative diff. Batch-2 workers receive batch-1 discoveries via automatic learning injection — so later batches always know what earlier batches found.

Sub-phase decomposition

Every non-trivial phase fans into named sub-phases.

DOCTRINE §12.2: each Step that can be parallelized decomposes into numbered sub-phases (Step 2a, 2b, 2c…). Each sub-phase runs independent workers in parallel and ends with its own worker-tier reviewer. The per-batch and final integration reviews still run on top — review happens at every granularity.

Sub-phases cannot be exactly 1 — they are either atomic-exempt (a single AskUserQuestion, one mechanical step) or they fan into ≥2 parallel angles. This rule prevents the appearance of parallelism without the substance. Cross-skill references like “dispatch Step 2” resolve to the sub-phase aggregate, so existing links don’t break.

Skills

14 specialized skills. Auto-routing on by default.

Say the verb — "audit the diff", "debug this test", "scope the new auth flow" — and the orchestrator routes automatically. No /hyperflow:* prefix required in auto mode. In Codex, hyperflow <skill> is the safest portable spelling, while /hyperflow:* remains an alias. amplify is the front door: it rewrites a rough prompt into the strongest version and hands off into the chain. scaffold sets a project up once; the operational utilities status, background, sticky, bridge, and flush run on their own.

Adaptive flow profiles

Triage picks the profile. Workers run at the right depth.

A 5-line edit gets fast (1 worker, inline review, ≤30k tokens) — not a 300k deep run. The triage call classifies { complexity, scope, risk, types, ambiguity } before any worker fires. A triage reviewer validates the classification before it propagates downstream. Profiles upgrade mid-flight on ESCALATE:; they downgrade when research shows the task is simpler than expected.

Pass --thorough to disable speed patterns (parallel sibling drafts, batched reviews, step skipping) for high-risk runs. Profile is visible in /hyperflow:status.

Specialist personas

15 composable expert personas. Stitched per task.

Every task is tagged with one or more types. The orchestrator stitches matching persona blocks into each worker prompt so every worker receives expert-level guidance for the exact work in front of it. A user-auth task tagged [api, db, security] gets all three personas composed in priority order inside a single prompt.

Personas compose by priority: security is stitched first so its constraints frame every other decision; creative is stitched last so divergent exploration adapts to structural choices above it.

Project memory

Persistent learnings. Local, version-controllable, never mixed across repos.

Memory lives at .hyperflow/memory/ — plain markdown, committed with the project, never uploaded. Hyperflow reads only tag-matched entries at session start and injects them into worker prompts automatically. Three tiers control injection cost.

Failure recovery

Retry. Escalate. Abort. Never silently swallow.

Every failure class has an explicit three-step policy. Worker error, malformed output, quality gate failure — all handled the same way, in every skill, with no improvisation. Three cumulative aborts across all batches halts the chain and surfaces the full failure trail.

Examples

Four flows. From quick fix to ambiguous design.

These are representative transcripts showing how the orchestrator selects a profile, fans out workers, and routes through review. Labels follow the output-style spec: bold for thinking-tier, plain for worker-tier.

Orchestration layers

10 composable layers.

Every chain skill declares which layers it exercises. The layer stack is non-negotiable — removing any layer breaks the orchestration contract.

Providers

One config. Auto-detected.

Provider is detected at session start from environment variables and folder presence. Override any model in ~/.hyperflow/config.json or switch mid-session.

Install

Direct from GitHub — verified and live.

The GitHub marketplace path ships every fix the day it lands. Official Anthropic marketplace ingestion is pending; use the direct path today.

Hyperflow runs locally in Codex App/CLI, Claude Code CLI, OpenCode CLI, or Antigravity. Codex maps skill aliases, question gates, subagents, and auto-chain handoffs through its plugin runtime. Claude Code Desktop and claude.ai web still need the portable CLAUDE.md fallback because they do not load terminal plugins.