Understanding the 16-Step Pipeline in Hyperresearch: From Query to Audited Report

The 16-step pipeline in Hyperresearch is a tier-adaptive, deterministic research engine that transforms a single query into a fully-audited report through sequential skill invocations, with step 6 serving as the critical synthesis point that reconciles divergent findings before adversarial criticism.

The jordan-gibbs/hyperresearch repository implements this pipeline as a series of discrete, resumable stages orchestrated by an entry-skill router. At runtime, the router classifies incoming queries into tiers (light, full, or dissertation) and loads a profile (light, full, premier, or custom) that scales numeric parameters—such as source counts, depth budgets, and draft iterations—defined in src/hyperresearch/core/profiles.py.

Pipeline Tiers and Profile Configuration

The pipeline adapts its execution path based on the selected tier and profile. The profile acts as a gear selector that determines which steps execute and at what intensity.

• Light tier: Executes a minimal path (steps 1, 2, 10, 15, 16) suitable for rapid answers.
• Full tier: Runs the complete sequence including investigation, synthesis, and criticism stages.
• Dissertation tier: Activates chapter partitioning (step 1.5) and loops steps 2 through 10 for each chapter group.

According to the source code in src/hyperresearch/core/profiles.py, each profile contains an ordered steps tuple that enumerates the exact sequence to execute and defines the numeric knobs consumed by each step.

The 16 Steps Explained

The pipeline progresses through the following deterministic stages, with fractional steps (1.5, 14.5) representing conditional sub-stages triggered only by specific tiers:

Step	Name	Function	Active Tiers
1	Decompose	Breaks queries into atomic items and builds a coverage matrix to determine the tier.	all
1.5	Chapter partition	Groups items into 4–10 chapters; subsequent steps loop per chapter.	dissertation
2	Width sweep	Plans multi-perspective searches and launches parallel fetcher waves.	all
3	Contradiction graph	Ranks contradictory statements across the corpus.	full
4	Loci analysis	Generates 1–8 depth loci with allocated source budgets.	full
5	Depth investigation	Investigates each locus, producing interim notes with committed positions.	full
6	Cross-locus reconcile	Reconciles committed positions from steps 4–5 into comparisons.md. This is the first synthesis operation aligning divergent findings.	full
7	Source tensions	Extracts expert disagreements into source-tensions.json.	full
8	Corpus critic	Identifies potential overturning sources and launches targeted gap-fill fetches.	full
9	Evidence digest	Produces top claims with verbatim quotes in evidence-digest.md.	full
10	Triple draft	Spawns 3 parallel draft sub-orchestrators (single draft for light tier).	all
11	Synthesize	Plans and executes a synthesizer agent to create the final report structure.	full
12	Critics	Runs four adversarial critics in parallel, emitting findings JSONs.	full
13	Gap-fetch	Performs targeted fetch waves for critic-identified gaps.	full
14	Patcher	Applies surgical edit hunks to the draft using tool-locked Read + Edit operations.	full
14.5	Cite-check	Verifies citation-sentence bindings with a skeptical LLM; applies a second patch pass.	full
15	Polish	Cleans filler text and enforces style hygiene (tool-locked).	all
16	Readability audit	Generates readability suggestions; orchestrator applies selective edits.	all

Step 6: The Cross-Locus Reconciliation Engine

Step 6 (Cross-locus reconcile) represents the pipeline’s pivotal transition from investigation to synthesis. Implemented via the skill slug hyperresearch-6-cross-locus-reconcile, this stage consumes the committed positions generated during loci analysis (step 4) and depth investigation (step 5) to produce comparisons.md.

Unlike earlier stages that focus on individual loci, step 6 performs the first cross-cutting synthesis, aligning divergent findings and resolving contradictions before the system initiates adversarial criticism. This ensures that subsequent critic stages evaluate a unified, coherent evidence base rather than fragmented notes.

Resumable Architecture and Skill Routing

Each pipeline run maintains state in a manifest located at research/runs/<vault_tag>/, enabling full resumability. The router dynamically loads skills only when needed, keeping context windows compact.

The skill resolution logic resides in src/hyperresearch/core/hooks.py, specifically within the step_skill_slug function, which maps step numbers to executable skill templates. When resuming, the CLI queries this manifest to determine the next step and exact skill to invoke.

# Initialize a new run with the default "full" profile

hyperresearch run init my-run-001

# Check current step position in the 16-step sequence

hyperresearch run status my-run-001

# Resume execution at the exact step and skill where the run paused

hyperresearch run resume my-run-001

# Output: my-run-001 — resume at step 6

#         Skill(skill: "hyperresearch-6-cross-locus-reconcile")

CLI Operations and Profile Management

Switching profiles alters the numeric parameters for steps without modifying the core logic. The premier profile, for example, increases the comparison count processed by step 6 and expands source budgets for depth investigations.

# Switch to high-scale "premier" profile

hyperresearch profile use premier

# Initialize a dissertation-tier run with chapter partitioning enabled

hyperresearch run init dissertation-run --profile dissertation
hyperresearch run resume dissertation-run  # Loops steps 2-10 per chapter

# Verify structural gates and step outputs (including step 6 comparisons)

hyperresearch run verify my-run-001

The src/hyperresearch/cli/run_cmd.py module implements these entry points, handling initialization, status reporting, and verification of the pipeline’s deterministic output gates.

Summary

• The 16-step pipeline in Hyperresearch is a deterministic, auditable sequence that converts queries into research reports through discrete skill invocations.
• Step 6 (Cross-locus reconcile) serves as the critical synthesis bottleneck, generating comparisons.md to align findings before criticism.
• Profiles (light, full, premier, dissertation) defined in src/hyperresearch/core/profiles.py control which steps execute and their resource allocation via the steps tuple.
• The architecture is fully resumable, with state tracked in run-specific manifests and skills loaded on-demand via step_skill_slug in src/hyperresearch/core/hooks.py.
• Tiers determine step eligibility: light skips synthesis stages, full executes the complete 16-step sequence, and dissertation activates chapter partitioning (step 1.5).

Frequently Asked Questions

What is the purpose of Step 6 (Cross-locus reconcile) in the Hyperresearch pipeline?

Step 6 acts as the pipeline’s primary synthesis mechanism, reconciling the divergent committed positions generated during loci analysis (step 4) and depth investigation (step 5) into a unified set of comparisons. This step produces comparisons.md and ensures that downstream critics evaluate a coherent, aligned evidence base rather than fragmented research notes.

How does the tier system affect which steps execute in the 16-step pipeline?

The tier system acts as a filtration layer: light tier executes only steps 1, 2, 10, 15, and 16 for rapid output; full tier activates the complete sequence including investigation, synthesis, and criticism; dissertation tier enables step 1.5 (chapter partitioning) and loops steps 2 through 10 for each chapter group, resulting in parallel sub-pipelines per chapter.

Can custom profiles modify the behavior of individual steps like Step 6?

Yes. Custom user-defined profiles in src/hyperresearch/core/profiles.py can override the numeric knobs that control step behavior, such as the number of comparisons generated by step 6 or the depth of source budget allocation. However, the core logic of each skill (e.g., hyperresearch-6-cross-locus-reconcile) remains consistent across profiles.

How does Hyperresearch ensure pipeline runs are resumable after interruption?

Each run maintains a manifest in research/runs/<vault_tag>/ that tracks the current step number and completion state. When executing hyperresearch run resume, the system reads this manifest, identifies the next step via step_skill_slug in src/hyperresearch/core/hooks.py, and invokes the corresponding skill without reprocessing completed stages, ensuring deterministic continuation from the exact point of interruption.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}