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

> Explore the 16-step pipeline in Hyperresearch, a deterministic engine that converts your query into an audited report. Discover how it synthesizes findings for adversarial criticism.

- Repository: [Jordan Gibbs/hyperresearch](https://github.com/jordan-gibbs/hyperresearch)
- Tags: deep-dive
- Published: 2026-09-13

---

**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`](https://github.com/jordan-gibbs/hyperresearch/blob/main/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`](https://github.com/jordan-gibbs/hyperresearch/blob/main/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`](https://github.com/jordan-gibbs/hyperresearch/blob/main/comparisons.md). This is the first synthesis operation aligning divergent findings. | full |
| 7 | **Source tensions** | Extracts expert disagreements into [`source-tensions.json`](https://github.com/jordan-gibbs/hyperresearch/blob/main/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`](https://github.com/jordan-gibbs/hyperresearch/blob/main/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`](https://github.com/jordan-gibbs/hyperresearch/blob/main/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`](https://github.com/jordan-gibbs/hyperresearch/blob/main/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.

```bash

# 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.

```bash

# 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`](https://github.com/jordan-gibbs/hyperresearch/blob/main/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`](https://github.com/jordan-gibbs/hyperresearch/blob/main/comparisons.md) to align findings before criticism.
- **Profiles** (`light`, `full`, `premier`, `dissertation`) defined in [`src/hyperresearch/core/profiles.py`](https://github.com/jordan-gibbs/hyperresearch/blob/main/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`](https://github.com/jordan-gibbs/hyperresearch/blob/main/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`](https://github.com/jordan-gibbs/hyperresearch/blob/main/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`](https://github.com/jordan-gibbs/hyperresearch/blob/main/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`](https://github.com/jordan-gibbs/hyperresearch/blob/main/src/hyperresearch/core/hooks.py), and invokes the corresponding skill without reprocessing completed stages, ensuring deterministic continuation from the exact point of interruption.