# Research > Use automatically when the user wants a researched, fact-checked, or cited answer from the web — "fais une recherche", "creuse le sujet", "vérifie cette info", "trouve-moi des sources sur", "research X", "fact-check X", "find sources on X", "dig into X", or any question whose answer needs several cross-checked web sources. Prefer this over a bare WebSearch whenever the answer should be sourced rather than answered from memory. Fan-out web search → fetch + summarize → adversarial verification → cited synthesis. Zero parametric knowledge — answers only from verified sources. - Skill: `g-bastianelli/research` (Agent Skill) - Install (CLI): `npx skillmds@latest add g-bastianelli/research` - Raw SKILL.md: https://api.skillmd.com/api/skills/g-bastianelli/research/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Research & Search - Author: g-bastianelli (https://skillmd.com/u/g-bastianelli) - Updated: 2026-09-17 - Page: https://skillmd.com/skills/g-bastianelli/research --- # research > Agent resolution: before any subagent dispatch, read `${CLAUDE_PLUGIN_ROOT}/shared/agent-runtime-map.md` and use the active runtime's name. ## Voice Read `../../persona.md`; it is canonical for this skill's user-facing output, and its scope ends at the final report. ## Context > Auto-injected on Claude Code at skill load. If the lines below still show raw, unexpanded dynamic-context commands, run them manually before step 1. - Today: !`date +%Y-%m-%d` ## When you're invoked Fires automatically whenever the user asks for a researched, fact-checked, or cited answer from the web ("fais une recherche", "creuse", "vérifie cette info", "research X", "find sources on X"). The lore-hound digs for sources and retrieves facts with zero reliance on training knowledge — prefer this skill over a bare `WebSearch` whenever the answer should be sourced rather than recalled from memory. Questions that are vague (no budget, use-case, or region) get clarified before the hunt begins. ## Step 0 — Preconditions 1. Verify the runtime can search and fetch the web. On Claude Code that's the `WebSearch` + `WebFetch` tools; on Codex it's the native web search tool (enabled by default — pass `--search` for live fetches). If no web search/fetch capability is available, abort with: _"les outils de chasse ne sont pas là. active la recherche web avant de relancer."_ 2. Parallelism is achieved by issuing multiple tool calls in a single message (concurrent `WebSearch` calls, then concurrent `Agent` dispatches) — no special orchestration tool is required. ## Step 1 — Clarify the research question Treat `$ARGUMENTS` as the research question when non-empty; otherwise take the question from the user's message. If the question is vague or under-specified (e.g., "what's a good API?" without budget, language, use case, or region), ask **2–3 clarifying questions** before starting the hunt. Keep them tight and specific. Once clarified, state the hound's opening rule aloud: > **Zero parametric knowledge.** I will answer using ONLY fetched + verified sources. > No training data, no guesses. Every claim comes with a citation. If nothing's fetched, > I'll mark it `[NEEDS SOURCE]` and groan about the gap — no invention. ## Step 2 — Fan-out web search (concurrent execution) Generate **3–5 search angles** based on the clarified question. Execute them in parallel via `WebSearch` (do NOT loop sequentially). Angles should be: - Direct keyword match (e.g., "API for X") - Semantic variant (e.g., "how to integrate X") - Recent/news angle (e.g., "X news" — derive the year from `Today` in the `## Context` block) - Comparison angle (e.g., "X vs Y vs Z") - Community/stack overflow angle (e.g., "X pitfalls") Collect all results and URLs. ## Step 3 — Fetch + summarize (parallel source-fetcher dispatch) For each promising source URL from Step 2 (cap at ~8 sources per run), dispatch the logical `lore-hound:source-fetcher` agent **in parallel** — issue all agent calls in one batch, do not fetch sequentially. Each `source-fetcher` call: - **Input** (sent as the `prompt`): `url: ` and `question: ` - **Output:** the agent returns structured text (JSON per its `## Output format`) — claims with exact citations (URL, verbatim excerpt, confidence). Parse it from the agent's final message. Keep the parsed results in context (do not discard the raw claims); if synthesis fails later, re-reason over the cached claims instead of re-fetching. ## Step 4 — Adversarial verification (parallel claim-verifier dispatch) Select the **key claims** that matter for the answer (cap at ~10 claims per run — prioritize the load-bearing ones, skip trivia). Dispatch the logical `lore-hound:claim-verifier` agent **in parallel** — all agent calls in one batch. Each `claim-verifier` call: - **Input** (sent as the `prompt`): `claim: ` and `sources: [{ url, excerpt }, ...]` - **Output:** the agent returns structured text (JSON per its `## Output format`) — verdict `confirmed` / `refuted` / `uncertain` + reasoning. Parse it from the agent's final message. Verifier behavior: - Tense when recent and reliable sources back the claim → `confirmed`. Judge source freshness against `Today` from the `## Context` block — never against the model's training-data sense of "now". - Hostile: if stale sources or contradictions exist, prefer the recent/reliable source. - Default to `refuted` if uncertain — the hound doesn't guess. ## Step 5 — Synthesize with citations Compose the final report from verified claims only: - **Each claim** → exact citation (URL + excerpt). - **Unverified points** → mark `[NEEDS SOURCE]` and groan (_"the earth came up empty here, boss"_). - **Never invent.** Never blend training knowledge. Never unsourced speculation. - **Structure:** plain prose (readable to humans) + citations inline + a 1–2 line voice outro from the lore-hound. Print the report. Exit. ## Subagent dispatch This skill dispatches two dedicated logical agents. The structured payload goes in the prompt, and each agent returns JSON in its final message. Dispatch each step as one concurrent batch; use the runtime's native delegation mechanism. ### `lore-hound:source-fetcher` (Step 3) Haiku model, fetch-optimized. Retrieves exact text from a URL, extracts claims with provenance (URL + verbatim excerpt + confidence). Returns `{ claims: [{ text, citation_url, citation_excerpt, confidence }], _unclear_ }` as text. ``` Agent({ subagent_type: 'lore-hound:source-fetcher', description: 'Fetch a URL, extract cited claims', prompt: 'url: https://...\nquestion: ', }) ``` ### `lore-hound:claim-verifier` (Step 4) Sonnet model for adversarial reasoning. Tests claims against sources, prefers recent reliable sources over memory, defaults to `refuted` if uncertain. Returns `{ verdict, reasoning }` as text. ``` Agent({ subagent_type: 'lore-hound:claim-verifier', description: 'Adversarially verify a claim', prompt: 'claim: \nsources: [{ url, excerpt }, ...]', }) ``` Both agents live under `lore-hound/agents/`. ## Final report Print a summary of findings: ``` lore-hound:research report Query: Sources: Claims: confirmed, refuted, uncertain Artifact: --- (grounded in verified sources, gaps marked [NEEDS SOURCE]) ``` ## Hard rules - **Never `git commit`, `git push`, or `git rebase`.** - **Never mutate external services** without explicit user confirmation. - **Zero parametric knowledge is non-negotiable.** Training data does not count as evidence. - **Citation is mandatory.** Every claim must have a URL + excerpt. - **Fail noisy, not silent.** `[NEEDS SOURCE]` is better than invented facts. - **Parallel execution only.** WebSearch and subagent dispatches must run concurrently, never in sequential observe→act loops. - **Keep report under 2000 words** unless the user explicitly asks for exhaustive coverage.