---
name: deep-research-analyst
description: "Expert guide for autonomous deep research, iterative web search, citation verification, evidence graph synthesis, and hallucination mitigation / Panduan ahli riset mendalam otonom, pencarian web iteratif, verifikasi sitasi, dan mitigasi halusinasi."
author: "Roedy Rustam"
version: "4.4.2"

---

# Deep Research Analyst (2026 Autonomous Research Edition)

[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)

---

<a name="english"></a>
## English

### Orchestration & Integration
- **Upstream Orchestrators**: Works under `brainstorming` and `zero-to-prod-orchestrator` (Phase 1 - Product Discovery, PRD & Architecture Selection) to resolve critical technical unknowns.
- **Downstream Cooperating Skills**:
  - `web-scraper` — Multi-strategy web content extraction and anti-bot bypass.
  - `browser-automation-expert` — Headless browser execution and interactive evidence gathering.
  - `prd-architect` — Integrate research findings into grounded PRD specifications and NFRs.
  - `multi-agent-orchestration` — Lead Intelligence Subagent in fan-out / fan-in research swarms.
  - `session-memory-manager` — Store evidence dossiers, citation maps, and research state checkpoints.

### Description
Production guide for architecting and executing autonomous **Deep Research** pipelines. Unlike simple one-shot retrieval (RAG), Deep Research operates as a goal-directed autonomous loop: decomposing queries into multi-perspective sub-questions, crawling and scraping academic/technical sources, scoring source credibility, cross-verifying facts across multiple independent citations, constructing an evidence graph, and synthesizing comprehensive, citation-grounded intelligence briefs.

**Swarm Synergy:** Within the **Fan-Out / Fan-In Research Swarm**, this skill acts as the Lead Intelligence Subagent. It is deployed in Phase 1 (Discovery & PRD) to gather ground truth, audit competitor architectures, and resolve high-risk technical unknowns before code is written.

### Trigger Conditions
- Requiring deep, multi-source investigation before architectural decision-making.
- Benchmarking libraries, database engines, or cloud architectures with empirical data.
- Building autonomous research agents, competitive intelligence scrapers, or literature synthesis tools.
- Eliminating LLM hallucinations in high-stakes technical or business documentation.
- Synthesizing complex multi-page web information into structured, cited intelligence reports.

### Deep Research Operational Workflow

```
1. QUERY DECOMPOSITION & HYPOTHESIS FORMULATION
   [User Objective] ──► [Query Expander] ──┬──► Sub-query A (Technical Specs)
                                           ├──► Sub-query B (Benchmarks & Limitations)
                                           └──► Sub-query C (Community Issues & Regressions)

2. RECURSIVE SOURCE DISCOVERY & CRAWLING
   [Sub-queries] ──► [Crawl4AI / Firecrawl / SerpAPI] ──► Raw Markdown / HTML Sources

3. SOURCE CREDIBILITY & FACT TRIANGULATION
   Raw Documents ──► [Evidence Evaluator] ──► Triangulate Facts (>= 2 Independent Sources)
                                          ──► Discard Low-Trust / SEO-Spam Content

4. EVIDENCE GRAPH SYNTHESIS & REPORTING
   Verified Facts ──► [Synthesizer Node] ──► Structured Report with Clickable Markdown Citations
```

### Core Implementation Guidelines

#### 1. Recursive Query Decomposer (Python / TypeScript)
Break high-level user requests into diverse search vectors targeting technical documentation, GitHub issues, and benchmarks:
```typescript
import { generateObject } from 'ai';
import { google } from '@ai-sdk/google';
import { z } from 'zod';

interface ResearchPlan {
  coreObjective: string;
  subQueries: Array<{
    query: string;
    focus: 'architecture' | 'benchmarks' | 'security' | 'pitfalls';
    expectedSourceType: 'docs' | 'github_repo' | 'benchmark_paper';
  }>;
}

export async function decomposeResearchQuery(userPrompt: string): Promise<ResearchPlan> {
  // Invariant: Gemini 4 Argon primary with automatic fallback to Gemini 3.8 Flash
  let modelInstance;
  try {
    modelInstance = google('gemini-4-argon');
  } catch (err) {
    console.warn('[DeepResearch] Gemini 4 Argon unavailable. Falling back to Gemini 3.8 Flash:', err);
    modelInstance = google('gemini-3.8-flash');
  }

  const { object } = await generateObject({
    model: modelInstance,
    schema: z.object({
      coreObjective: z.string(),
      subQueries: z.array(z.object({
        query: z.string().describe('Precise keyword search query with technical operators'),
        focus: z.enum(['architecture', 'benchmarks', 'security', 'pitfalls']),
        expectedSourceType: z.enum(['docs', 'github_repo', 'benchmark_paper']),
      })).min(3).max(6),
    }),
    prompt: `Analyze the following research objective and decompose it into 4-6 targeted, non-overlapping search vectors: "${userPrompt}"`,
  });

  return object;
}
```

#### 2. Python Implementation: Autonomous Extraction
```python
from crawl4ai import AsyncWebCrawler, CrawlerRunConfig, CacheMode
from pydantic import BaseModel, Field
from pydantic_ai import Agent

class ResearchFinding(BaseModel):
    claim: str = Field(description="Technical claim extracted")
    confidence: float = Field(ge=0, le=1, description="Confidence score")
    source_url: str = Field(description="Source URL")
    corroborating_sources: list[str] = Field(default_factory=list)

# Invariant: Try Gemini 4 Argon with graceful fallback to Gemini 3.8 Flash
try:
    research_agent = Agent(
        'google-gla:gemini-4-argon',
        result_type=list[ResearchFinding],
        system_prompt="Extract and verify technical claims with confidence scores."
    )
except Exception:
    research_agent = Agent(
        'google-gla:gemini-3.8-flash',
        result_type=list[ResearchFinding],
        system_prompt="Extract and verify technical claims with confidence scores."
    )

async def deep_research(query: str) -> list[ResearchFinding]:
    config = CrawlerRunConfig(cache_mode=CacheMode.BYPASS)
    async with AsyncWebCrawler() as crawler:
        result = await crawler.arun(url=f"https://search-url/{query}", config=config)
        findings = await research_agent.run(result.markdown)
        return findings.data
```

#### 3. Vector Store Caching for Intermediate Results
Caching intermediate research results in vector stores prevents redundant crawling and accelerates knowledge retrieval:
- **Storage:** Use `pgvector` or local `FAISS` for caching crawled page embeddings.
- **Deduplication:** Deduplicate sources via cosine similarity before processing.
- **Invalidation:** Implement TTL-based cache invalidation for time-sensitive research (e.g., fast-moving API docs).
- **Example Flow:**
  ```python
  # Store page chunks in vector store
  vector_store.add_texts(chunks, metadata=[{"url": url, "timestamp": now}])
  # Retrieve similar past findings
  cached = vector_store.similarity_search(query, k=3, filter={"ttl_valid": True})
  ```

#### 4. Episodic Research Memory
Maintain research memory across sessions to build continuous intelligence:
- **Storage:** Store research dossiers as episodic memories in `session-memory-manager`.
- **Knowledge Graphs:** Build cumulative knowledge graphs from multiple research sessions, linking related concepts over time.
- **Cross-referencing:** Cross-reference past findings with new queries to compound understanding without starting from scratch.

#### 5. Source Credibility & Fact Triangulation Protocol
Never accept a claim from a single unverified blog post. Require citation triangulation:
- **Tier 1 (Highest Confidence):** Official documentation, source code repositories, peer-reviewed benchmarks, RFCs.
- **Tier 2 (Medium Confidence):** Production engineering blogs (Uber, Netflix, Cloudflare), maintainer posts.
- **Tier 3 (Verify Required):** Forum discussions, social threads, unverified community tutorials.
- **Rule of Triangulation:** Any non-trivial technical claim must be confirmed by at least two independent sources or verified against raw benchmark code.

#### 6. Structured Evidence Graph Output
Every research brief produced by this skill must adhere to the following markdown template:
```markdown
# [Topic] — Deep Research & Evidence Dossier

## Executive Summary
- Concise 3-5 bullet takeaway synthesis.

## Evidence Matrix
| Technical Claim | Verified Status | Confidence (0-100%) | Primary Source | Corroborating Source |
|---|---|---|---|---|
| Claim Description | Confirmed / Disputed | 95% | [Source A](url) | [Source B](url) |

## Trade-off Analysis & Key Risks
- Concrete architectural trade-offs, cold-start latencies, memory footprint, or pricing cliff.

## Recommended Architectural Decision
- Prescriptive guidance for implementation swarms with justification.
```

### Sovereign Execution, Token Efficiency & Invariants
| Dimension | Sovereign Mandate & Deterministic Contract |
| :--- | :--- |
| **Frontier Model Cascade** | Medium / High (`Gemini 4 Argon`, `GPT-5.6 Sol Medium`, `Claude Sonnet 5.5 High`) |
| **Availability Fallback** | `Gemini 4 Argon/Pro` -> `Gemini 3.8 Flash`; `Claude Opus 5.5` -> `Claude Opus 4.6` (Zero unhandled missing-model errors) |
| **KV-Cache & Token Protocol** | Pin static instructions & schemas at prompt prefix (`kv-cache-prefix-optimizer`); pass surgical `CONTEXT_MAP.md` slices (<250 tokens/call) during Swarm Fan-Out |
| **SaaT CLI & MCP Dispatch** | CLI: `vibes skill exec deep-research-analyst <audit\|eval\|verify\|generate\|blueprint>` / MCP: `vibes_skill_dispatch`, `vibes_eval_sql`, `vibes_verify_invariants`, `vibes_verify_gate` |
| **NFR & Anti-Slop Invariants** | P99 Query Latency < 15ms, 100% Row Level Security (RLS) coverage on multi-tenant tables, explicit B-Tree indexes on all Foreign Keys; 100% complete zero-placeholder output verified via `node scripts/check-anti-slop.js --strict` |

---


---

<a name="bahasa-indonesia"></a>
## Bahasa Indonesia

### Integrasi Orkestrasi
- **Orkestrator Hulu**: Beroperasi di bawah arahan `brainstorming` dan `zero-to-prod-orchestrator` (Fase 1 - Discovery Produk, PRD & Pemilihan Arsitektur) untuk mengatasi ketidakpastian teknis krusial.
- **Skill Hilir & Kerja Sama**:
  - `web-scraper` — Ekstraksi konten web multi-strategi dan bypass anti-bot.
  - `browser-automation-expert` — Eksekusi browser headless dan pengumpulan bukti interaktif.
  - `prd-architect` — Mengintegrasikan temuan riset ke dalam spesifikasi PRD dan NFR.
  - `multi-agent-orchestration` — Subagen Analis Utama dalam swarm riset fan-out / fan-in.
  - `session-memory-manager` — Menyimpan dokumen bukti, peta sitasi, dan checkpoint status riset.

### Deskripsi
Panduan produksi untuk merancang dan mengeksekusi pipeline **Riset Mendalam Otonom (Deep Research)**. Berbeda dari retrieval sederhana (RAG satu langkah), Deep Research beroperasi sebagai siklus otonom terarah: memecah pertanyaan menjadi sub-vektor dari berbagai sudut pandang, merayapi dan mengekstrak sumber teknis/akademis, menilai kredibilitas sumber, memvalidasi silang fakta (*fact triangulation*) di minimal 2 sumber independen, membangun graf bukti, dan menyusun laporan intelijen komprehensif berlandaskan sitasi yang valid.

**Sinergi Swarm:** Dalam topologi **Fan-Out / Fan-In Research Swarm**, skill ini berperan sebagai Sub-agen Analis Utama. Diterapkan pada Fase 1 (Discovery & PRD) untuk mengumpulkan fakta objektif, mengaudit arsitektur kompetitor, dan mengeliminasi ketidakpastian teknis berisiko tinggi sebelum penulisan kode dimulai.

### Kondisi Pemicu
- Membutuhkan penyelidikan multi-sumber yang mendalam sebelum membuat keputusan arsitektur.
- Melakukan benchmark komparatif library, database engine, atau infrastruktur cloud berbasis data empiris.
- Membangun agen riset otonom, alat pemantau kompetitor, atau sintesis literatur otomatis.
- Mengeliminasi halusinasi LLM pada dokumen teknis atau strategi bisnis berisiko tinggi.
- Merangkum informasi web yang rumit dan tersebar menjadi dokumen ringkasan terstruktur dengan sitasi klik langsung.

---

### Alur Kerja Operasional Riset Mendalam

```
1. DEKOMPOSISI KUERI & HIPOTESIS
   [Tujuan Riset] ──► [Query Expander] ──┬──► Sub-kueri A (Spesifikasi Teknis)
                                         ├──► Sub-kueri B (Benchmark & Batasan)
                                         └──► Sub-kueri C (Isu Komunitas & Regresi)

2. PERAYAPAN SUMBER REKURSIF
   [Sub-kueri] ──► [Crawl4AI / Firecrawl / SerpAPI] ──► Dokumen Mentah (Markdown/HTML)

3. TRIANGULASI FAKTA & KREDIBILITAS
   Dokumen Mentah ──► [Evidence Evaluator] ──► Validasi Silang (>= 2 Sumber Independen)
                                           ──► Eliminasi Konten SEO-Spam & Blog Rendah Kredibilitas

4. SINTESIS GRAF BUKTI & LAPORAN
   Fakta Terverifikasi ──► [Synthesizer Node] ──► Laporan Terstruktur dengan Sitasi Klik Langsung
```

---

### Panduan Implementasi Inti

#### 1. Dekomposisi Kueri Rekursif (TypeScript & AI SDK)
```typescript
import { generateObject } from 'ai';
import { google } from '@ai-sdk/google';
import { z } from 'zod';

interface RencanaRiset {
  tujuanUtama: string;
  subKueri: Array<{
    kueri: string;
    fokus: 'arsitektur' | 'benchmark' | 'keamanan' | 'kelemahan';
    jenisSumber: 'dokumentasi' | 'repositori_github' | 'paper_teknis';
  }>;
}

export async function dekomposisiTujuanRiset(promptPengguna: string): Promise<RencanaRiset> {
  // Invarian: Gemini 4 Argon primer dengan pengalihan otomatis ke Gemini 3.8 Flash
  let modelTarget;
  try {
    modelTarget = google('gemini-4-argon');
  } catch (galat) {
    console.warn('[DeepResearch] Gemini 4 Argon belum tersedia. Mengalihkan ke Gemini 3.8 Flash:', galat);
    modelTarget = google('gemini-3.8-flash');
  }

  const { object } = await generateObject({
    model: modelTarget,
    schema: z.object({
      tujuanUtama: z.string(),
      subKueri: z.array(z.object({
        kueri: z.string().describe('Kueri kata kunci spesifik dengan operator pencarian teknis'),
        fokus: z.enum(['arsitektur', 'benchmark', 'keamanan', 'kelemahan']),
        jenisSumber: z.enum(['dokumentasi', 'repositori_github', 'paper_teknis']),
      })).min(3).max(6),
    }),
    prompt: `Analisis tujuan riset berikut dan pecah menjadi 4-6 vektor pencarian teknis yang spesifik: "${promptPengguna}"`,
  });

  return object;
}
```

#### 2. Ekstraksi Otonom & Evaluasi Klaim (Python & Crawl4AI)
```python
from crawl4ai import AsyncWebCrawler, CrawlerRunConfig, CacheMode
from pydantic import BaseModel, Field
from pydantic_ai import Agent

class TemuanRiset(BaseModel):
    klaim_teknis: str = Field(description="Klaim teknis spesifik yang diekstraksi")
    skor_keyakinan: float = Field(ge=0, le=1, description="Skor keyakinan bukti (0 sampai 1)")
    url_sumber: str = Field(description="URL sumber primer")
    sumber_pendukung: list[str] = Field(default_factory=list, description="Daftar URL sumber pembanding")

# Invarian: Utamakan Gemini 4 Argon dengan pengalihan otomatis ke Gemini 3.8 Flash
try:
    agen_analis = Agent(
        'google-gla:gemini-4-argon',
        result_type=list[TemuanRiset],
        system_prompt="Ekstrak temuan teknis obyektif beserta skor keyakinan dan sumber referensi."
    )
except Exception:
    agen_analis = Agent(
        'google-gla:gemini-3.8-flash',
        result_type=list[TemuanRiset],
        system_prompt="Ekstrak temuan teknis obyektif beserta skor keyakinan dan sumber referensi."
    )

async def eksekusi_riset_mendalam(kueri: str) -> list[TemuanRiset]:
    config = CrawlerRunConfig(cache_mode=CacheMode.BYPASS)
    async with AsyncWebCrawler() as crawler:
        halaman = await crawler.arun(url=f"https://search-engine.internal/q={kueri}", config=config)
        hasil = await agen_analis.run(halaman.markdown)
        return hasil.data
```

#### 3. Protokol Triangulasi Fakta & Skor Keyakinan
1. **Tier 1 (Otoritas Tertinggi):** Dokumentasi resmi, repositori kode sumber terbuka, spesifikasi RFC, dan laporan audit formal.
2. **Tier 2 (Dapat Diandalkan):** Blog teknik produksi dari tim rekayasa industri (Netflix, Cloudflare, Uber, Stripe).
3. **Tier 3 (Perlu Verifikasi Lanjutan):** Thread forum komunitas dan tutorial opini pribadi.
4. **Aturan Mutlak Triangulasi:** Setiap keputusan arsitektural krusial wajib didukung oleh sekurang-kurangnya 2 sumber Tier 1/2 independen.

#### 4. Format Laporan Riset Terstruktur (Evidence Dossier)
Setiap ringkasan intelijen riset wajib disusun dalam format markdown berikut:
```markdown
# [Topik Riset] — Laporan Riset Mendalam & Graf Bukti

## Ringkasan Eksekutif
- Sintesis ringkas 3-5 poin keputusan utama.

## Matriks Bukti Teknis
| Klaim Teknis | Status Validasi | Skor Keyakinan | Sumber Primer | Sumber Pendukung |
|---|---|---|---|---|
| Penjelasan Klaim | Terverifikasi / Dibantah | 95% | [Sumber A](url) | [Sumber B](url) |

## Analisis Komparatif & Risiko Kunci
- Trade-off latensi, batas memori, konsumsi biaya, atau kurva migrasi.

## Keputusan Arsitektur yang Direkomendasikan
- Arahan preskriptif untuk tim pengembang dengan justifikasi berbasis bukti.
```

### Matriks Eksekusi Berdaulat, Efisiensi Token & Invarian
| Dimensi | Mandat Berdaulat & Kontrak Deterministik |
| :--- | :--- |
| **Kaskade Model Frontier** | Medium / High (`Gemini 4 Argon`, `GPT-5.6 Sol Medium`, `Claude Sonnet 5.5 High`) |
| **Invarian Fallback Ketersediaan** | `Gemini 4 Argon/Pro` -> `Gemini 3.8 Flash`; `Claude Opus 5.5` -> `Claude Opus 4.6` (Bebas gagal saat model belum tersedia/kuota penuh) |
| **Protokol Hemat Token & KV-Cache** | Kunci instruksi & skema statis di prefix awal (`kv-cache-prefix-optimizer`); kirim potongan `CONTEXT_MAP.md` (<250 token/panggilan) saat Fan-Out |
| **Eksekusi SaaT CLI & MCP** | CLI: `vibes skill exec deep-research-analyst <audit\|eval\|verify\|generate\|blueprint>` / MCP: `vibes_skill_dispatch`, `vibes_eval_sql`, `vibes_verify_invariants`, `vibes_verify_gate` |
| **Invarian NFR & Anti-Slop** | Latensi Query P99 < 15ms, cakupan Row Level Security (RLS) 100% pada tabel multi-tenant, indeks B-Tree eksplisit pada seluruh Foreign Key; kode 100% tuntas tanpa placeholder diverifikasi melalui `node scripts/check-anti-slop.js --strict` |