Parallax Discovery

Multi-agent, multi-pass deep investigation methodology for achieving true understanding of complex systems. Named after astronomical parallax — determining a star's true position by observing it from multiple angles — the methodology dispatches independent agents with genuinely different perspectives, then reconciles their findings to achieve depth that single-perspective investigation cannot.

When to Use

Use Parallax Discovery when:

• You need true understanding of a complex system, not a quick answer
• The system has multiple interacting mechanisms or cross-cutting concerns
• Documentation may be incomplete, outdated, or misleading
• Previous investigation attempts produced confident but wrong conclusions
• You're making architectural decisions that depend on how things actually work

Don't use it when:

• You need a quick factual answer (use direct search or a focused agent)
• The question is narrow and well-defined
• The cost of being wrong is low

Parallax Discovery is expensive — it dispatches many agents across multiple waves. Use it when the cost of misunderstanding exceeds the cost of thorough investigation.

Quick Start

1. Install the bundle

Add the bundle to your Amplifier configuration:

includes:
  - bundle: git+https://github.com/bkrabach/amplifier-bundle-parallax-discovery@main

Or compose just the behavior onto an existing bundle:

includes:
  - behavior: git+https://github.com/bkrabach/amplifier-bundle-parallax-discovery@main#subdirectory=behaviors/parallax-discovery.yaml

2. Activate discovery mode

In an Amplifier session:

/discovery

This activates the discovery mode with the full methodology context, specialized agents, and the parallax-methodology skill available via /skill parallax-methodology.

3. Run a full investigation via recipe

For a complete multi-wave investigation with approval gates:

execute parallax-discovery:recipes/parallax-discovery.yaml with target='Amplifier ecosystem' target_dir='/path/to/target' topics='["skills mechanism", "recipes mechanism", "hooks mechanism"]'

The recipe walks through all four waves with human approval gates between each, allowing you to steer the investigation as it progresses.

The Methodology

Parallax Discovery proceeds through four waves that narrow scope and increase rigor:

$ \text{Wave} 1: \text{Discovery} (\text{broad}, \text{triplicate} \text{teams}) │ 3 \text{agents} \times \text{N} \text{topics} → \text{independent} \text{findings} ▼ \text{Lead} \text{Investigator} \text{Reconciliation} → \text{Approval} \text{Gate} ▼ \text{Wave} 2: \text{Verification} (\text{focused}, \text{per}-\text{discrepancy}) │ \text{Expert} \text{agents} \text{resolve} \text{discrepancies} \text{with} \text{file}:\text{line} \text{evidence} ▼ \text{Lead} \text{Investigator} \text{Reconciliation} → \text{Approval} \text{Gate} ▼ \text{Wave} 3: \text{Adversarial} (\text{execution}-\text{based} \text{challenges}) │ \text{Antagonist} \text{agents} \text{write} \text{tests}, \text{run} \text{code}, \text{prove} \text{or} \text{disprove} ▼ \text{Lead} \text{Investigator} \text{Reconciliation} → \text{Approval} \text{Gate} ▼ \text{Wave} 4: \text{Synthesis} │ \text{Reconcile} \text{all} \text{waves} \text{into} \text{final} \text{deliverables} ▼ \text{Context} \text{Transfer} \text{Package} $

Key principles:

• Multi-perspective — Every topic gets 3 independent agents with fresh context. No agent inherits another's biases.
• Progressive depth — Discovery → Verification → Adversarial → Synthesis. Each wave narrows scope and increases rigor.
• Execution-based evidence — Code reading identifies mechanisms; execution proves impact.
• Discrepancies are information — When agents disagree, investigate the disagreement. Never reconcile by fiat.

The Five Agents

Agent	Role	Focus
code-tracer	Traces HOW things work	Execution paths, LSP navigation, file:line evidence for every claim
behavior-observer	Catalogs WHAT exists	10+ real instances, quantified patterns, reality vs. documentation
integration-mapper	Maps WHERE things connect	Cross-boundary analysis, composition effects, emergent behavior
lead-investigator	Reconciles findings	Cross-cutting insights, discrepancy tracking, wave planning
antagonist	Adversarial tester	Execution-based falsification, test scripts, claim stress testing

In Wave 1, the first three agents form triplicate teams — each investigating the same topic from a different angle. The lead investigator reconciles after each wave. The antagonist appears in Wave 3, receiving no prior findings and attempting to disprove claims through execution.

The Four Modes

Mode	Wave	Purpose
/discovery	Wave 1	Broad triplicate team exploration — cast a wide net
/verification	Wave 2	Focused code-level deep dives — file:line evidence required
/adversarial	Wave 3	Execution-based challenges — write tests, run code, prove or disprove
/synthesis	Wave 4	Reconcile all waves into a coherent context transfer package

Activate any mode with the slash command. Each mode configures the session with appropriate context, tool emphasis, and evidence standards for that wave.

The Recipes

parallax-discovery.yaml — Full Investigation

Orchestrates a complete investigation through all four waves with human approval gates.

execute parallax-discovery:recipes/parallax-discovery.yaml with \
  target='Description of the target system' \
  target_dir='/path/to/local/clone' \
  topics='["topic 1", "topic 2", "topic 3"]'

Context variables:

• target (required) — Description of what's being investigated
• target_dir (required) — Path to the locally cloned target system
• topics (required) — JSON array of investigation topics
• investigation_dir (optional) — Workspace path (defaults to {target_dir}/.investigation)

Approval gates between waves let you steer the investigation — add topics, reprioritize, skip waves, or redirect focus based on what's been found so far.

parallax-wave.yaml — Single Wave

Runs one wave standalone. Called by the main recipe but can also be used directly:

execute parallax-discovery:recipes/parallax-wave.yaml with \
  wave_name='discovery' \
  topics='["topic 1", "topic 2"]' \
  target_dir='/path/to/target' \
  investigation_dir='/path/to/.investigation' \
  wave_dir='/path/to/.investigation/wave-1-discovery'

Bundle Contents

parallax-discovery/
├── bundle.md                              # Bundle manifest and overview
├── behaviors/
│   └── parallax-discovery.yaml            # Behavior definition (agents, modes, tools, hooks)
├── agents/
│   ├── code-tracer.md                     # HOW — traces execution paths
│   ├── behavior-observer.md               # WHAT — catalogs real instances
│   ├── integration-mapper.md              # WHERE — maps cross-boundary connections
│   ├── lead-investigator.md               # Reconciles findings across agents
│   └── antagonist.md                      # Adversarial tester — execution-based falsification
├── modes/
│   ├── discovery.md                       # Wave 1 mode definition
│   ├── verification.md                    # Wave 2 mode definition
│   ├── adversarial.md                     # Wave 3 mode definition
│   └── synthesis.md                       # Wave 4 mode definition
├── context/
│   ├── methodology.md                     # Core methodology — governing principles, evidence hierarchy
│   ├── triplicate-pattern.md              # Why 3 agents, the three roles, agent selection
│   ├── artifact-strategy.md               # Directory structure, file types, notes protocol
│   └── wave-protocol.md                   # Detailed protocol for each wave type
├── skills/
│   └── parallax-methodology/
│       └── SKILL.md                       # Discoverable skill — full methodology reference
├── recipes/
│   ├── parallax-discovery.yaml            # Full multi-wave investigation orchestrator
│   └── parallax-wave.yaml                 # Single wave sub-recipe
└── templates/
    └── investigation-workspace/           # Reference workspace directory layout

Origin

Parallax Discovery was developed through a real investigation of the Amplifier ecosystem — 18 agent investigations across 3 waves, producing 80+ artifact files and 10+ DOT diagrams. The methodology proved itself:

• Every triplicate team had unique findings per agent, including two confirmed bugs and the governing architectural principle of the target system
• The adversarial wave found a real bug with two live collision sites that 18 agents of code reading across two waves could not determine
• The integration mapper role consistently produced the most architecturally significant insights by looking at the spaces between mechanisms

The methodology, agent definitions, and recipes in this bundle encode the patterns and practices that emerged from that investigation.