Claude Code /deep-research Built-in Workflow

// Built-in Claude Code /deep-research workflow shape
// Observed from Claude Code 2.1.157 generated workflow script.
// The real script is launched as /deep-research <question> inside Claude Code.

export const meta = {
  name: "deep-research",
  description:
    "Deep research harness — fan-out web searches, fetch sources, adversarially verify claims, synthesize a cited report.",
  whenToUse:
    "When the user wants a deep, multi-source, fact-checked research report on any topic.",
  phases: [
    { title: "Scope", detail: "Decompose question into search angles" },
    { title: "Search", detail: "Parallel WebSearch agents, one per angle" },
    { title: "Fetch", detail: "URL-dedup, fetch sources, extract falsifiable claims" },
    { title: "Verify", detail: "3-vote adversarial verification per claim" },
    { title: "Synthesize", detail: "Merge dupes, rank confidence, cite sources" },
  ],
}

const VOTES_PER_CLAIM = 3
const REFUTATIONS_REQUIRED = 2
const MAX_FETCH = 15
const MAX_VERIFY_CLAIMS = 25

phase("Scope")
const QUESTION = (typeof args === "string" && args.trim()) || ""
if (!QUESTION) {
  return { error: "No research question provided. Pass it as /deep-research <question>." }
}

const scope = await agent(
  "Decompose this research question into complementary search angles. " +
  "Generate distinct web search queries that cover the question from different angles. " +
  "Return structured output only.",
  { label: "scope", schema: SCOPE_SCHEMA }
)

const searchResults = await pipeline(
  scope.angles,
  angle => agent(SEARCH_PROMPT(angle), {
    label: "search:" + angle.label,
    phase: "Search",
    schema: SEARCH_SCHEMA,
  }),
  searchResult => {
    const novel = dedupeAndBudget(searchResult.results, MAX_FETCH)
    return parallel(
      novel.map(source => () =>
        agent(FETCH_PROMPT(source, searchResult.angle), {
          label: "fetch:" + host(source.url),
          phase: "Fetch",
          schema: EXTRACT_SCHEMA,
        })
      )
    )
  }
)

const rankedClaims = rankClaims(searchResults).slice(0, MAX_VERIFY_CLAIMS)

phase("Verify")
const voted = await parallel(
  rankedClaims.map(claim => () =>
    parallel(
      Array.from({ length: VOTES_PER_CLAIM }, (_, voter) => () =>
        agent(VERIFY_PROMPT(claim, voter), {
          label: "v" + voter + ":" + claim.claim.slice(0, 40),
          phase: "Verify",
          schema: VERDICT_SCHEMA,
        })
      )
    ).then(verdicts => {
      const valid = verdicts.filter(Boolean)
      const refuted = valid.filter(v => v.refuted).length
      const survives =
        valid.length >= REFUTATIONS_REQUIRED &&
        refuted < REFUTATIONS_REQUIRED
      return { ...claim, verdicts: valid, refutedVotes: refuted, survives }
    })
  )
)

phase("Synthesize")
const report = await agent(
  "Synthesize confirmed claims into a cited research report. " +
  "Merge semantic duplicates, assign confidence, note caveats, and list open questions.",
  { label: "synthesize", schema: REPORT_SCHEMA }
)

return {
  question: QUESTION,
  ...report,
  stats: {
    sourcesFetched: searchResults.flat().length,
    claimsVerified: voted.length,
    confirmed: voted.filter(c => c.survives).length,
    killed: voted.filter(c => !c.survives).length,
  },
}