Skip to content
Internals — research note: investigation or findings, not a description of shipped behaviour.

Deep Research Waves, Batches, and Competitive SOTA Analysis (2026)

This document provides a technical, code-level architectural analysis comparing Vox Deep Research (Scientia / vox-research-shim) against the two leading proprietary industry implementations: Google Gemini Deep Research and Anthropic Claude Deep Research (Claude Agent SDK / Coworker).

It details how Vox can not only match the iterative reasoning, multi-hop web retrieval, and subagent delegation of Gemini and Claude, but exceed them through local-first asymmetric routing, persistent cross-session knowledge graphs (VoxDB FTS5), sandboxed empirical verification (compilers and schema validators), multi-wave tree-of-thought exploration, and intelligent context window distillation.


1. Executive Summary & Frontier Competitive Benchmark

Section titled “1. Executive Summary & Frontier Competitive Benchmark”

The table below contrasts the four systems across the key dimensions that govern autonomous deep research:

Capability DimensionGoogle Gemini Deep ResearchAnthropic Claude Deep ResearchVox Scientia (Current Shipped)Vox Scientia (Target Architecture)
Execution LoopRecursive search-read-synthesize loop (10–30+ iterations)Hub-and-spoke subagent tree (orchestrator + worker agents)Single-pass 10-stage pipeline (decompose $\to$ gather $\to$ verify $\to$ synth)Multi-Wave DAG Engine (Wave 1 Recon $\to$ Wave 2 Deep-Dive $\to$ Wave 3 Adversarial)
Context Window StrategyBrute-force 1M–2M token context ingestion of raw HTMLVirtual filesystem offload; subagent summary compressionFixed-length snippet truncation (context_max_chars: 12000)Hierarchical Distillation: local MENS extraction into factual triplets + RAG budgeter
Search BackendsGoogle Search native indexBrave / SerpAPI / Custom web fetchersSearXNG + DuckDuckGo fallback + Tavily /research tierSearXNG + DDG + Tavily + DOI/CrossRef + local VoxDB FTS5 memory
Claim VerificationImplicit internal LLM reasoning; opaque verificationMulti-agent debate & source cross-referencingSelfCheckGPT 3x resampling + NLI classificationMulti-Signal Triangulation: 3x NLI resampling + CrossRef + Sandbox empirical validation
Empirical ValidationNone (pure text inference)None (pure text inference)rustc sandbox verification for CodeGen domainPlug-in Sandboxes: Compiler execution (rustc/Wasm), API schema checking, price verification
Durable Storage & DedupEphemeral or cloud conversation historyEphemeral per-session virtual filesVoxDB SQLite FTS5 index + 14-day claim cacheDurable FTS5 Knowledge Base with cross-session claim deduplication & provenance graphs
Token Cost & EconomicsHigh ($2–$10 per run on Gemini Pro)Very High ($5–$25 per run on Sonnet/Opus)Asymmetric: local MENS for claims, OpenRouter for synthesisZero-Cost Intermediate Tiers: Local MENS for extraction/verification, paid model for synthesis
Offline & PrivacyZero (100% Google Cloud dependent)Zero (100% Anthropic API dependent)Local search (Tantivy/Mem) + Ollama/MENS supportFull Offline Air-Gapped Mode: Local SearXNG + Ollama MENS + VoxDB FTS5
Dynamic EscalationMonolithic (Deep Research mode toggle)Monolithic (subagent research command)Manual flags (force_research, verify_claims)Autonomous 4-Tier Triage: Tier 0 Memory $\to$ Tier 1 Shallow $\to$ Tier 2 Deep $\to$ Tier 3 Multi-Wave
Batch OrchestrationSingle interactive jobSingle job per sessionSerial execution in daemonHopper Concurrent Batches: Actor-based multi-query research with token rate-limiting
Interactive SteeringCollaborative plan review before executionInteractive prompt correctionsFire-and-forget daemon run (start_research_async)Mid-Flight Steering: Progressive wave events, human-in-the-loop clarification & refinement
Hallucination DefensePost-hoc citations (occasionally hallucinated)Subagent citation extractionSpan overlap audit + Refuted verdict bannersDeterministic Citation Precision Gate: Exact character span match + two-source corroboration

2. Anatomy of Frontier Deep Research Systems

Section titled “2. Anatomy of Frontier Deep Research Systems”

Google Gemini Deep Research leverages Google’s core competitive assets: native access to the Google web search index and Gemini’s massive 1M–2M token context window.

2.1 Google Gemini Deep Research, diagram 110 nodes, 11 edges: User Prompt → Collaborative Plan Form…; Collaborative Plan Form… → User Approves Plan?; User Approves Plan? → Collaborative Plan Form…; User Approves Plan? → Start Recursive Agent L…; Start Recursive Agent L… → Generate 3-8 Subqueries; Generate 3-8 Subqueries → Google Search Ing…User PromptCollaborative PlanFormulationUser Approves Plan?Start Recursive Agent LoopGenerate 3-8 SubqueriesGoogle Search IngestionIngest Full HTML Pages (upto 1M tokens)Information Gap orContradiction Detected?Formulate Refined /Follow-up QueriesSynthesize 10-25 Page Reportwith CitationsNoYesYes (Iter < Max)No or Iter == Max
Diagram source
graph {
node UserQuery: "User Prompt"
node PlanPhase: "Collaborative Plan Formulation"
node UserApproval: "User Approves Plan?" { shape: diamond }
node LoopStart: "Start Recursive Agent Loop"
node GenQueries: "Generate 3-8 Subqueries"
node GoogleSearch: "Google Search Ingestion"
node IngestPages: "Ingest Full HTML Pages (up to 1M tokens)"
node GapAnalysis: "Information Gap or Contradiction Detected?" { shape: diamond }
node RefineQueries: "Formulate Refined / Follow-up Queries"
node LongSynthesis: "Synthesize 10-25 Page Report with Citations"
UserQuery -> PlanPhase
PlanPhase -> UserApproval
UserApproval -> PlanPhase: "No"
UserApproval -> LoopStart: "Yes"
LoopStart -> GenQueries
GenQueries -> GoogleSearch
GoogleSearch -> IngestPages
IngestPages -> GapAnalysis
GapAnalysis -> RefineQueries: "Yes (Iter < Max)"
RefineQueries -> GoogleSearch
GapAnalysis -> LongSynthesis: "No or Iter == Max"
}
  1. Long-Context Raw Ingestion: By accepting 100+ pages in full text without lossy snippet summarization, the model preserves nuanced tables, footnotes, and edge-case data.
  2. Collaborative Planning: The system presents a detailed multi-section research plan to the user before launching execution, allowing the user to redirect the investigation upfront.
  3. Iterative Reformulation: The agent evaluates whether gathered information actually answers the sub-questions; if a gap is identified, it generates targeted second- and third-order search queries.
  1. Opaque Verification: Citations are generated generative-first; there is no formal character-level evidence span validation or NLI cross-checking against ground truth.
  2. Zero Empirical Grounding: The system cannot test code samples, check whether an API endpoint actually exists, or run a compiler. Technical claims are accepted purely on web consensus.
  3. Cloud Lock-in & Privacy: Every search query, visited URL, and page token is processed through Google Cloud. Confidential corporate codebases and internal documentation cannot be researched securely.

2.2 Anthropic Claude Deep Research (Claude Agent SDK / Coworker)

Section titled “2.2 Anthropic Claude Deep Research (Claude Agent SDK / Coworker)”

Anthropic’s approach relies on hierarchical multi-agent delegation (an Orchestrator supervising specialized Worker Subagents) and a virtual filesystem.

2.2 Anthropic Claude Deep Research (Claude Agent SDK / Coworker), diagram 213 nodes, 16 edges: User Query → Lead Researcher (Superv…; Lead Researcher (Superv… → Task Decomposition & Ro…; Task Decomposition & Ro… → Worker Subagent 1: Topi…; Task Decomposition & Ro… → Worker Subagent 2: Topi…; Task Decomposition & Ro… → Worker Subagent N: Topi…; Worker Subagent 1: Topi… → W…User QueryLead Researcher (SupervisorAgent)Task Decomposition & Router(Claude Haiku)Worker Subagent 1: Topic AWorker Subagent 2: Topic BWorker Subagent N: Topic CWrite Notes to VirtualFilesystemWrite Notes to VirtualFilesystemWrite Notes to VirtualFilesystemSubagents Distill StructuredFindingsGaps / Contradictions Found?Spawn Specialist Subagent(Tie-Breaker)Synthesize ComprehensiveReport (Claude Opus/Sonnet)YesNo
Diagram source
graph {
node UserQuery: "User Query"
node LeadAgent: "Lead Researcher (Supervisor Agent)"
node Decomp: "Task Decomposition & Router (Claude Haiku)"
node Subagent1: "Worker Subagent 1: Topic A"
node Subagent2: "Worker Subagent 2: Topic B"
node SubagentN: "Worker Subagent N: Topic C"
node VFS1: "Write Notes to Virtual Filesystem"
node VFS2: "Write Notes to Virtual Filesystem"
node VFS3: "Write Notes to Virtual Filesystem"
node Distill: "Subagents Distill Structured Findings"
node Reflection: "Gaps / Contradictions Found?" { shape: diamond }
node SpawnSpecialist: "Spawn Specialist Subagent (Tie-Breaker)"
node FinalReport: "Synthesize Comprehensive Report (Claude Opus/Sonnet)"
UserQuery -> LeadAgent
LeadAgent -> Decomp
Decomp -> Subagent1
Decomp -> Subagent2
Decomp -> SubagentN
Subagent1 -> VFS1
Subagent2 -> VFS2
SubagentN -> VFS3
VFS1 -> Distill
VFS2 -> Distill
VFS3 -> Distill
Distill -> LeadAgent
LeadAgent -> Reflection
Reflection -> SpawnSpecialist: "Yes"
SpawnSpecialist -> Distill
Reflection -> FinalReport: "No"
}
  1. Context Compression via Delegation: Instead of flooding a single context window with noisy web scraper logs, worker subagents read sources in isolated scratchpads and report only compressed, structured factual claims back to the supervisor.
  2. Multi-Model Routing: Cost optimization using lightweight models (Haiku) for query routing, URL extraction, and preliminary filtering, reserving expensive frontier models (Opus / Sonnet 3.5) for synthesis and conflict resolution.
  3. Reflective Reflection: The supervisor compares findings across subagents, identifies contradictory claims, and spawns targeted tie-breaker subagents.
  1. Excessive Cost: Running 5–15 recursive frontier agent loops costs between $5 and $25 per query, making continuous or automated usage prohibitive for individual developers.
  2. Amnesic Execution: Findings exist in ephemeral subagent scratchpads. Subsequent runs on related topics start completely from scratch with zero cross-session memory.
  3. No Local Sandbox Verification: Like Gemini, Claude Deep Research cannot execute code or verify compiler correctness for software engineering questions.

3. Vox Target Architecture: Closing Gaps & Exceeding the Frontier

Section titled “3. Vox Target Architecture: Closing Gaps & Exceeding the Frontier”

Vox can surpass both Gemini and Claude Deep Research by unifying five pillars into a cohesive architecture:

3. Vox Target Architecture: Closing Gaps & Exceeding the Frontier, diagram 318 nodes, 20 edges: Wave 1: Reconnaissance → MENS Local Claim Extrac…; MENS Local Claim Extrac… → Gap & Contradiction Ana…; Gap & Contradiction Ana… → Wave 2: Targeted Deep-D…; Wave 2: Targeted Deep-D… → MENS Local Evidence Tri…; MENS Local Evidence Tri… → Adversarial Bar Met?; Adversarial Bar Met?…Autonomous Multi-Wave DAGEngineUser / Chat QueryDynamic Triage ClassifierReturn VoxDB FTS5 CachedKnowledge (<50ms)Fast 1-Hop Search + DirectSynth (<1s)Context Window Budgeter(Top-K Spans)Frontier Model Synthesis(OpenRouter / Claude /Gemini)Post-Hoc Citation Span & DOIAuditPersist to VoxDB FTS5 &Claim CacheInteractive GUI Report +Claim Accordion + Chat CardWave 1: ReconnaissanceMENS Local Claim Extraction& TripletsGap & Contradiction AnalyzerWave 2: Targeted Deep-Dive &Citation CrawlingMENS Local EvidenceTriangulationAdversarial Bar Met?Wave 3: AdversarialVerification & SandboxExecutionRun Sandboxed Compiler /Schema ValidatorConsolidated KnowledgeSubgraphContradiction / MissingDepthHigh Uncertainty / CodeQuerySufficient EvidenceSufficientTier 0: Exact MemoryTier 1: Shallow FactTier 2: Standard DeepTier 3: Multi-Wave
Diagram source
graph {
node UserAsk: "User / Chat Query"
node Triage: "Dynamic Triage Classifier" { shape: diamond }
node ReturnMem: "Return VoxDB FTS5 Cached Knowledge (<50ms)"
node FastWeb: "Fast 1-Hop Search + Direct Synth (<1s)"
node ContextPacker: "Context Window Budgeter (Top-K Spans)"
node FrontierSynth: "Frontier Model Synthesis (OpenRouter / Claude / Gemini)"
node PostAudit: "Post-Hoc Citation Span & DOI Audit"
node StoreDB: "Persist to VoxDB FTS5 & Claim Cache"
node PresentGUI: "Interactive GUI Report + Claim Accordion + Chat Card"
container MultiWaveEngine: "Autonomous Multi-Wave DAG Engine" {
node Wave1: "Wave 1: Reconnaissance"
node Distill1: "MENS Local Claim Extraction & Triplets"
node GapAnalysis: "Gap & Contradiction Analyzer" { shape: diamond }
node Wave2: "Wave 2: Targeted Deep-Dive & Citation Crawling"
node Distill2: "MENS Local Evidence Triangulation"
node AdversarialCheck: "Adversarial Bar Met?" { shape: diamond }
node Wave3: "Wave 3: Adversarial Verification & Sandbox Execution"
node SandboxRun: "Run Sandboxed Compiler / Schema Validator"
node FinalDistill: "Consolidated Knowledge Subgraph"
Wave1 -> Distill1
Distill1 -> GapAnalysis
GapAnalysis -> Wave2: "Contradiction / Missing Depth"
Wave2 -> Distill2
Distill2 -> AdversarialCheck
AdversarialCheck -> Wave3: "High Uncertainty / Code Query"
Wave3 -> SandboxRun
SandboxRun -> FinalDistill
GapAnalysis -> FinalDistill: "Sufficient Evidence"
AdversarialCheck -> FinalDistill: "Sufficient"
}
UserAsk -> Triage
Triage -> ReturnMem: "Tier 0: Exact Memory"
Triage -> FastWeb: "Tier 1: Shallow Fact"
Triage -> MultiWaveEngine.Wave1: "Tier 2: Standard Deep"
Triage -> MultiWaveEngine.Wave1: "Tier 3: Multi-Wave"
MultiWaveEngine.FinalDistill -> ContextPacker
ContextPacker -> FrontierSynth
FrontierSynth -> PostAudit
PostAudit -> StoreDB
StoreDB -> PresentGUI
}

Pillar I: Multi-Wave Iterative Execution (Batches & Waves)

Section titled “Pillar I: Multi-Wave Iterative Execution (Batches & Waves)”

Instead of a monolithic single-hop query decomposition, Vox executes research across sequential Waves, where each wave’s hypotheses and contradictions dynamically parameterize the next wave:

1. Wave 1: Reconnaissance & Broad Horizon Scanning

Section titled “1. Wave 1: Reconnaissance & Broad Horizon Scanning”
  • Objective: Establish the broad knowledge boundaries and identify candidate claims.
  • Decomposition: LLM decomposes user query into 3–6 exploratory search queries.
  • Retrieval: Parallel web search across SearXNG, DuckDuckGo, and Tavily.
  • Extraction: Local MENS model extracts factual claims and builds initial candidate claim set $C_1$.
  • Gap Detection: Evaluates $C_1$ for:
    • Unverified claims (claims where source evidence confidence $< 0.6$).
    • Contradictory claims (two sources asserting opposing facts, e.g., different release dates or benchmark scores).
    • Information blind spots (subqueries that returned 0 high-trust hits).

2. Wave 2: Targeted Deep-Dives & Contradiction Resolution

Section titled “2. Wave 2: Targeted Deep-Dives & Contradiction Resolution”
  • Objective: Resolve contradictory claims and drill into specific primary sources.
  • Targeted Query Generation: Converts unresolved claims into interrogative queries:
    • Example: If Source A claims “Feature X was deprecated in v0.6” and Source B claims “Feature X was deprecated in v0.7”, Wave 2 generates: "exact release notes deprecation Feature X v0.6 v0.7".
  • Recursive Link Exploration: Follows citations, source URLs, and GitHub PR links found in Wave 1 pages.
  • Triangulation: Re-verifies claims against primary sources (official documentation, release tags, DOI papers).

3. Wave 3: Adversarial Verification & Empirical Validation

Section titled “3. Wave 3: Adversarial Verification & Empirical Validation”
  • Objective: Stress-test the leading conclusions and empirically validate technical claims.
  • Adversarial Counter-Querying: Generates queries designed to falsify the dominant claim:
    • Example: "Is [Claim X] incorrect or debunked?", "Known bugs or limitations of [Claim X]".
  • Sandboxed Execution (The Vox Unfair Advantage):
    • CodeGen Mode: If research concerns code APIs or language behavior, the agent synthesizes a minimal test harness and runs rustc or vox check inside a sandboxed environment to empirically verify compilation and runtime behavior.
    • Shopping Mode: Verifies real-time pricing, validates merchant URL integrity, and checks schema.org structured pricing data.
  • Convergence Scoring: Computes a mathematical stability metric $S \in [0.0, 1.0]$. If $S \ge 0.85$, the engine terminates and proceeds to synthesis; otherwise, it flags residual uncertainty.

Pillar II: Dynamic Escalation & Intelligent Triage

Section titled “Pillar II: Dynamic Escalation & Intelligent Triage”

Deep research takes 15–45 seconds and consumes resources. A user asking “What is the latest stable version of Rust?” should not endure a 3-wave 40-source deep research loop, while a user asking “Compare memory layouts and lock contention between jemalloc and mimalloc in multi-threaded Rust” requires deep research.

The Orchestrator introduces a 4-Tier Escalation Classifier:

pub enum ResearchTriageTier {
/// Tier 0: Direct hit in VoxDB FTS5 knowledge base (< 50ms, 0 tokens).
InstantMemory { cached_doc_id: i64 },
/// Tier 1: Fast single web lookup + direct synthesis (< 1.5s, low cost).
ShallowWeb { query: String },
/// Tier 2: Standard single-wave deep research with claim verification (5–12s).
StandardDeep { query: ResearchQuery },
/// Tier 3: Multi-wave autonomous deep research with adversarial verification (15–45s).
MultiWaveAutonomous { query: ResearchQuery, max_waves: usize },
}
  1. Memory Lookup: Query scientia_research_fts in VoxDB. If a verified claim or research synthesis exists from within the last 14 days with similarity score $> 0.85$, return immediately as Tier 0.
  2. Complexity & Intent Analysis:
    • High complexity signals: “compare”, “benchmark”, “why does”, “pros and cons”, “trace”, “architecture”, “dispute”, “history of”. $\to$ Tier 3 (Multi-Wave).
    • Domain triggers: shopping queries, code generation queries, CVE security inquiries. $\to$ Tier 2 or 3.
    • Simple factual signals: “what is the version of”, “who founded”, “release date of”, “syntax for”. $\to$ Tier 1 (Shallow).
  3. Explicit User Override:
    • Chat slash command /research --deep forces Tier 3.
    • Chat slash command /research --quick forces Tier 1.
    • Chat toggle force_research: true escalates to at least Tier 2.

Pillar III: Context Window Distillation & RAG Budgeting

Section titled “Pillar III: Context Window Distillation & RAG Budgeting”

Feeding 30 full web pages into an LLM synthesis prompt creates Context Poisoning and causes the model to ignore nuanced evidence.

Vox solves this through Hierarchical Distillation:

Pillar III: Context Window Distillation & RAG Budgeting, diagram 46 nodes, 5 edges: Raw Web Pages (100k+ to… → Local MENS Model (Fast); Local MENS Model (Fast) → Structured Claim Triple…; Structured Claim Triple… → Factual Subgraph & Corr…; Factual Subgraph & Corr… → RAG Context Budgeter (T…; RAG Context Budgeter (T… → Dense, High-Density Syn…Raw Web Pages (100k+ tokens)Local MENS Model (Fast)Structured Claim Triplets &Evidence SpansFactual Subgraph &Corroboration MatrixRAG Context Budgeter (Top-KVerified Spans)Dense, High-DensitySynthesis Prompt (<8ktokens)
Diagram source
graph {
direction: right
node RawHits: "Raw Web Pages (100k+ tokens)"
node LocalMENS: "Local MENS Model (Fast)"
node FactTriplets: "Structured Claim Triplets & Evidence Spans"
node GraphStore: "Factual Subgraph & Corroboration Matrix"
node RAGBudgeter: "RAG Context Budgeter (Top-K Verified Spans)"
node PackedPrompt: "Dense, High-Density Synthesis Prompt (<8k tokens)"
RawHits -> LocalMENS
LocalMENS -> FactTriplets
FactTriplets -> GraphStore
GraphStore -> RAGBudgeter
RAGBudgeter -> PackedPrompt
}
  1. Local Extraction: For each retrieved web hit, a lightweight local model (or fast cloud model) extracts a list of ClaimEvidenceUnit:
    pub struct ClaimEvidenceUnit {
    pub subject: String,
    pub predicate: String,
    pub object: String,
    pub evidence_span: String,
    pub source_url: String,
    pub trust_score: f64,
    pub is_verified: bool,
    }
  2. Knowledge Subgraph Deduplication: Claim triplets are grouped by semantic equivalence. Multiple sources asserting the same claim increment its corroboration count.
  3. RAG Budget Packing: The synthesis prompt is constructed by packing top-ranked verified evidence spans until the configured context_max_chars (e.g. 16,000 chars) is reached. Irrelevant boilerplate, navigation bars, and marketing fluff are completely discarded before frontier synthesis.

Pillar IV: Batch Research & Hopper Concurrency

Section titled “Pillar IV: Batch Research & Hopper Concurrency”

Users and automated agents often need to research matrices of topics (e.g., evaluating 10 competing open-source crates or researching 8 components of a technical architecture).

Vox unifies research with the Vox Orchestrator Hopper:

  • Batch Enqueueing:
    pub struct ResearchBatchRequest {
    pub batch_id: String,
    pub topics: Vec<ResearchQuery>,
    pub max_concurrency: usize,
    pub stop_on_failure: bool,
    }
  • Actor Pool Execution: Tasks are pushed to the VoxDbHopper. Worker actors pick up tasks, coordinating rate limits across search engines (SearXNG RPM limits, Tavily monthly quotas) and LLM providers.
  • Aggregation: Once all topics in the batch complete, the Hopper triggers a comparative synthesis step that generates a unified comparison matrix.

Pillar V: Full Chat Integration & Progressive Streaming

Section titled “Pillar V: Full Chat Integration & Progressive Streaming”

To make deep research seamless from the chat interface:

  1. Interactive Chat Commands:
    • /research [topic] — Runs triage-directed research.
    • /research --waves=3 [topic] — Forces 3-wave multi-wave research.
    • /research --domain=shopping [product] — Invokes product search with merchant & price verification.
    • /research --domain=codegen [language/task] — Invokes code research with sandboxed compiler validation.
  2. Progressive Turn Events: The orchestrator emits live streaming events to the GUI via Tauri events (chat:turn:event):
    • WaveStarted { wave_index: 1, total_waves: 3, plan: [...] }
    • SourcesRetrieved { count: 12, top_domains: [...] }
    • ContradictionDetected { claim_a: "...", claim_b: "..." }
    • WaveStarted { wave_index: 2, focus: "Resolving contradiction on release dates" }
    • EmpiricalValidationCompleted { sandbox: "rustc", passed: true }
  3. At-Will Saving & Workspace Ingestion: Every research result in the chat displays action buttons:
    • Save to Workspace: Writes a clean Markdown document into docs/src/architecture/ with validated frontmatter.
    • Pin to Knowledge Base: Stores verified claims into the project’s permanent memory.
    • View Trust Inspection: Expands the ResearchClaimAccordion with NLI confidence scores and corroboration badges.

4. Technical Gap Analysis & Actionable Remediation Plan

Section titled “4. Technical Gap Analysis & Actionable Remediation Plan”

Based on codebase analysis across vox-research-shim, vox-orchestrator, vox-orchestrator-mcp, vox-db, and vox-gui, the following table details the implementation roadmap to bridge all remaining gaps:

ComponentCurrent StateRequired Target ImplementationFiles to Modify / Create
Multi-Wave PipelineSingle-wave execution in pipeline.rsWaveEngine orchestrating Wave 1, Wave 2 (contradiction resolution), and Wave 3 (adversarial + sandbox)crates/vox-research-shim/src/research/orchestrator/wave.rs, pipeline.rs
Orchestrator Research Dispatchperform_autonomous_research in research_dispatch.rs calls vox_search::run_multi_hop_web_research directlyRoute through run_research_with_context_and_session in vox-research-shim with proper session tracking and claim verificationcrates/vox-orchestrator/src/orchestrator/task_dispatch/research_dispatch.rs
Dynamic Triage ClassifierAd-hoc flags in chat message handlingclassify_research_intent evaluating query complexity, local FTS5 matches, and explicit flagscrates/vox-research-shim/src/research/orchestrator/triage.rs, message.rs
Context Window DistillationRaw string concatenation of hit snippets up to char limitStructured ClaimEvidenceUnit extraction via local MENS model and RAG budget packingcrates/vox-research-shim/src/research/stages/distillation.rs
Batch Research APIOnly single-session executionresearch_batch_start in MCP / daemon handling ResearchBatchRequest via Hoppercrates/vox-orchestrator-mcp/src/memory_tools/handlers_memory.rs, hopper.rs
Chat Progressive StreamingSynchronous blocking call returning one combined stringAsync event stream emitting per-wave progress milestones to chat_turn eventscrates/vox-orchestrator-mcp/src/chat_tools/chat/message.rs, chat_turn.rs

By implementing multi-wave DAG execution, sandboxed empirical validation, persistent cross-session knowledge graphs (VoxDB FTS5), and local-first asymmetric distillation, Vox achieves an autonomous deep research capability that:

  1. Exceeds Gemini Deep Research in trust and verifiability: Providing transparent, character-level NLI-verified evidence spans, compiler-validated code snippets, and 100% offline air-gapped execution capability.
  2. Exceeds Claude Deep Research in cost and persistence: Eliminating frontier token waste through local MENS extraction, while accumulating durable knowledge in a local database that accelerates future research runs.
  3. Integrates natively into daily developer workflow: Seamlessly available in the chat composer, CLI, daemon, and GUI with interactive steering and at-will persistence.