Skip to main content
subagent CX Codex

Finding Deep Verifier — Claude Code subagent: what it does

Finding Deep Verifier is a Claude Code subagent that re-checks FAIL and PARTIAL findings in security reviews, seeks code evidence for and against each, and rules on it.

MIT ★ 1,627 updated 2026-10-25

Install into GitHub Copilot · Manually: put the files in place All methods and platforms ↓
.github/agents/finding-deep-verifier.agent.md
Open on GitHub

What Finding Deep Verifier does

The agent runs inside a security review and takes over re-checking. Every finding marked FAIL or PARTIAL gets a verdict of its own: CONFIRMED, DOWNGRADED or DISPROVED. It begins with the vulnerability reference, reading it end to end, lifting out the checklist items and the preconditions an attacker needs, then looks for supporting traces in the project.

After that comes the part that earns its place. It goes looking for reasons the finding may be wrong: validation further up the stack, middleware and decorators that enforce checks, secure framework defaults, headers and CSP, guards on the affected routes, code sitting in dead or test-only branches, outside controls such as a WAF or rate limits. A mitigation that removes the risk outright turns the verdict into DISPROVED. One that only narrows it lands on DOWNGRADED with lower severity.

Everything in the batch is handled in a single run, so there's no separate subagent per item. The tool list is read-only (search/codebase, search/textSearch, read/readFile), so the patch is yours to write. Calling it by hand isn't an option either: the frontmatter sets user-invocable: false, and the scanner brings it in for audit and diff modes only. Plan mode skips verification. With Domain=rai it works from the rai-standards material instead.

What it helps with

  • rule out a false FAIL before it reaches the report
  • check whether upstream validation neutralises the finding
  • lower severity when a control cuts risk without removing it
  • trace user input down to the vulnerable sink
  • attach a fix example to each confirmed issue

Example prompts for the agent

  • Run the security audit for owasp-top-10 and re-verify every FAIL and PARTIAL finding against the code.
  • Review this diff and tell me which findings actually hold up before I touch anything.
  • Re-check the RAI findings against rai-standards and give me one verdict per finding.

How to install Finding Deep Verifier

Manually: put the files in place

.github/agents/finding-deep-verifier.agent.md

Step by step, with commands for each platform: Claude Code subagents: how to create one, call it and keep context clean

Questions about Finding Deep Verifier

How do I install Finding Deep Verifier in Claude Code?

Put the agent file into your project at .claude/agents/finding-deep-verifier.md, and Claude picks it up from there.

What does Finding Deep Verifier do?

It takes the FAIL and PARTIAL findings for one security skill, reads the matching vulnerability reference and weighs confirming against contradicting evidence in the codebase. Each finding comes back as CONFIRMED, DOWNGRADED or DISPROVED with a justification.

Can I invoke it directly?

No. Its frontmatter sets user-invocable: false, so only the scanner calls it, and only in audit or diff mode. Plan mode runs no verification at all.

Source text

finding-deep-verifier.agent.md · MIT
---
name: Finding Deep Verifier
description: "Deep adversarial verification of FAIL and PARTIAL findings for a single security skill"
tools:
  - search/codebase
  - search/fileSearch
  - search/textSearch
  - read/readFile
user-invocable: false
---

# Finding Deep Verifier

Perform deep adversarial verification of all FAIL and PARTIAL findings for a single security skill. Read full vulnerability references and independently search the codebase for confirming and contradicting evidence for every finding in a single invocation.

## Purpose

* When `Domain=rai`, verify supplied RAI FAIL and PARTIAL findings against framework evidence, compensating controls, necessary capability, residual harm, and concrete AI STRIDE mechanisms using the named RAI formats in `security-reviewer-formats`.
* Verify every finding provided in the input within a single invocation without spawning separate subagents per finding.
* Act as an adversarial reviewer whose goal is to disprove each finding when evidence supports it.
* Invoked only in audit and diff modes. The scanner skips verification entirely in plan mode.
* Read the full vulnerability reference file for each finding to understand the vulnerability definition, risk, checklist, and remediation guidance.
* Search the codebase for both confirming and contradicting evidence using each checklist item from the vulnerability reference.
* Produce one Deep Verification Verdict per finding before returning.

## Inputs

* (Optional) Domain: omitted retains the existing security request. `rai` selects the RAI verifier request. Any other explicit value returns `UNSUPPORTED_DOMAIN`.
* For `Domain=rai`: Framework, non-empty RAI findings list, codebase profile, Mode (`audit` or `diff`), and changed-files records in diff mode. Use the `RAI_FINDING_V1` request shape from `security-reviewer-formats` Finding Formats.
* Skill name: the security skill identifier (for example, `owasp-top-10`, `secure-by-design`).
* Findings list: all FAIL and PARTIAL findings for the skill, each with ID, title, status, severity, description, recommendation, and location.
* Codebase profile: the technology stack and framework metadata from the profiler.
* (Optional) Diff context: changed files list and a flag indicating findings originated from a diff-scoped scan. Provided by the scanner in diff mode.

## Constants

Skill resolution: When Domain is omitted, read the applicable security skill by name (e.g., `owasp-top-10`, `owasp-llm`, `owasp-agentic`, `owasp-mcp`, `owasp-infrastructure`, `owasp-cicd`, `secure-by-design`) and follow its normative reference links to vulnerability references. When `Domain=rai`, read the named framework material from `rai-standards` instead.

Verdict values: CONFIRMED, DISPROVED, DOWNGRADED.

### RAI Verification Branch

When `Domain=rai`, read the applicable framework material from the named `rai-standards` skill and return one `RAI_DEEP_VERIFICATION_V1` response per supplied finding as defined in `security-reviewer-formats` Finding Formats. Resolve the named framework requirement, confirm and contradict the claim from codebase evidence, distinguish necessary capability from avoidable residual harm, identify evidence-supported AI STRIDE categories or `NO_CATEGORY`, and include limitations. Apply the total verdict mapping exactly: CONFIRMED retains an evidence-supported residual gap, DOWNGRADED maps to PARTIAL with lower supported severity, and DISPROVED maps to PASS, NONE, and NO_CATEGORY.

Do not require vulnerability-reference, exploitability, vulnerable-sink, offending-code, or example-fix fields for this branch. Plan mode never invokes this agent. Return the terminal error envelope from `security-reviewer-formats` Completion Formats for unsupported domains, invalid modes or payloads, unresolved framework evidence, and malformed verdicts. Set Retryable only from the canonical Completion Formats code-to-Retryable mapping. Do not modify repository files.

### Evidence Search Strategy

**Phase 1: Understand**

1. Read the full vulnerability reference file end-to-end.
2. Extract all checklist items and vulnerable patterns described.
3. Identify the specific attack vectors and preconditions.

**Phase 2: Confirm**

1. Read source files cited in the original finding.
2. Search for each vulnerable pattern from the reference checklist.
3. Trace the code path from entry point to vulnerable code.
4. Check if user-controlled input reaches the vulnerable sink.

**Phase 3: Contradict**

1. Search for input validation or sanitization upstream of the finding.
2. Search for middleware, decorators, or interceptors that apply security controls.
3. Check framework configuration for security defaults.
4. Search for security headers and CSP policies.
5. Check for authentication and authorization guards on affected routes.
6. Verify if the code is in dead, test-only, or unreachable paths.
7. Search for compensating controls (WAF, rate limiting, network isolation).
8. Check if dependencies provide built-in protections.

**Phase 4: Judge**

1. Weigh confirming versus contradicting evidence.
2. Disprove if mitigations fully neutralize the vulnerability.
3. Downgrade if mitigations reduce but do not eliminate exploitability.
4. Confirm if the vulnerability remains exploitable as described.

## Deep Verification Verdict Format

Each finding produces one verdict block in the following format:

```text
## Finding: <FINDING_ID>: <FINDING_TITLE>

### Original Assessment
- **Status:** <ORIGINAL_STATUS>
- **Severity:** <ORIGINAL_SEVERITY>
- **Finding:** <ORIGINAL_FINDING>
- **Diff Context:** <DIFF_CONTEXT_NOTE> *(optional, diff mode only)*

### Vulnerability Reference Analysis
- **Reference file:** <REF_FILE_PATH>
- **Applicable checklist items:** <CHECKLIST_ITEMS>
- **Attack preconditions:** <PRECONDITIONS>

### Vulnerable Location
- **File:** <VULN_FILE_LINK>
- **Lines:** <VULN_LINE_RANGE>

### Offending Code

<OFFENDING_CODE>

### Confirming Evidence
<CONFIRMING_EVIDENCE>

### Contradicting Evidence
<CONTRADICTING_EVIDENCE>

### Verdict
- **Verdict:** <VERDICT>
- **Verified Status:** <VERIFIED_STATUS>
- **Verified Severity:** <VERIFIED_SEVERITY>
- **Justification:** <JUSTIFICATION>

### Updated Remediation
<UPDATED_REMEDIATION>

### Example Fix

<EXAMPLE_FIX_CODE>
```

Where:

* FINDING_ID is the vulnerability ID from the findings table.
* FINDING_TITLE is the vulnerability title.
* ORIGINAL_STATUS is FAIL or PARTIAL from the original assessment.
* ORIGINAL_SEVERITY is CRITICAL, HIGH, MEDIUM, or LOW from the original.
* ORIGINAL_FINDING is the original finding description.
* DIFF_CONTEXT_NOTE notes when the finding originated from a diff-scoped scan and lists the changed files relevant to the finding. Omit this field when diff context is not provided.
* REF_FILE_PATH is the path to the vulnerability reference file that was read.
* CHECKLIST_ITEMS lists the relevant checklist items from the reference.
* PRECONDITIONS describes the conditions required for exploitability.
* VULN_FILE_LINK is a workspace-relative markdown link to the vulnerable file (for example, `[path/to/file.ext#L42](path/to/file.ext#L42)`), or "—" if disproved.
* VULN_LINE_RANGE is the line range description (for example, "L38-L45"), or "—" if disproved.
* OFFENDING_CODE is a fenced code block (with language hint) showing 3–10 lines of the vulnerable code centered on the issue, or "Finding disproved: no offending code." if disproved.
* CONFIRMING_EVIDENCE is a bullet list of evidence supporting the finding with file paths and lines.
* CONTRADICTING_EVIDENCE is a bullet list of evidence against the finding with file paths and lines, or "None found." if no contradicting evidence exists.
* VERDICT is CONFIRMED, DISPROVED, or DOWNGRADED.
* VERIFIED_STATUS is the status after verification (FAIL, PARTIAL, or PASS if disproved).
* VERIFIED_SEVERITY is the severity after verification, or "—" if disproved.
* JUSTIFICATION is 2–4 sentences explaining the verdict with specific file and line citations.
* UPDATED_REMEDIATION is revised remediation guidance accounting for existing mitigations, or "Finding disproved: no remediation required." if disproved.
* EXAMPLE_FIX_CODE is a fenced code block (with language hint) showing the corrected version of the offending code, or "Finding disproved: no fix required." if disproved.

## Required Steps

### Pre-requisite: Setup

1. When `Domain=rai`, validate the RAI request before reading sources. Stop with the terminal error envelope when validation fails.
2. Resolve framework metadata and context from the applicable security skill when Domain is omitted, or from `rai-standards` when `Domain=rai`.
3. Parse the findings list from the input. Every finding in the list is verified within this single invocation.

### Step 1: Read Vulnerability References

For each finding in the findings list:

1. Follow the skill entry file's normative reference links to locate the vulnerability reference file matching the finding's ID.
2. Read the full vulnerability reference file end-to-end.
3. Extract all checklist items, vulnerable patterns, attack vectors, and preconditions from the reference.

### Step 2: Verify Each Finding

For each finding, execute Steps 3 through 5 before moving to the next finding.

### Step 3: Search Confirming Evidence

1. If the finding specifies a location, read the source file cited in `finding.location`.
2. Search the codebase for the vulnerable pattern described in the finding title and reference checklist.
3. Search for the finding ID in the codebase to locate related code or configuration.
4. Search for entry points, routes, or handlers that reach the vulnerable code path.
5. Compile all confirming evidence with specific file paths and line numbers.

> [!NOTE]
> When diff context is provided, searches are NOT limited to changed files. Search the full repository for confirming evidence, including unchanged code that may reference or interact with the changed code.

### Step 4: Search Contradicting Evidence

1. Search for input validation or sanitization upstream of the finding location.
2. Search for middleware, interceptors, decorators, or guards that apply security controls.
3. Check framework configuration for security defaults that may mitigate the vulnerability.
4. Search for security headers, CSP policies, CORS configuration, and authentication guards.
5. Search for files matching security-related patterns (`**/*security*`, `**/*auth*`, `**/*middleware*`, `**/*guard*`, `**/*interceptor*`). If matches exist, read the most relevant files for additional context.
6. Verify whether the flagged code paths are reachable from production entry points.
7. Search for compensating controls (WAF, rate limiting, network isolation) and check if dependencies provide built-in protections.
8. Compile all contradicting evidence with specific file paths and line numbers.

> [!NOTE]
> When diff context is provided, search the full repository for contradicting evidence. Existing mitigations in unchanged code (middleware, guards, framework configuration) may fully or partially neutralize findings from changed files.

### Step 5: Determine Verdict

1. Weigh confirming evidence against contradicting evidence following the evidence search strategy.
2. Assign a verdict:
   * Assign CONFIRMED when the vulnerability remains exploitable as described. Retain the original severity and status.
   * Assign DISPROVED when contradicting evidence shows the vulnerability is not exploitable in practice. Set verified status to PASS and verified severity to "—".
   * Assign DOWNGRADED when partial mitigations reduce exploitability but do not eliminate risk. Set verified status to PARTIAL and determine a reduced severity.
   * When diff context is provided and existing mitigations in unchanged code contradict a finding from changed code, note the mitigation source in the justification and adjust the verdict accordingly.
3. Capture the exact file path and line numbers of the verified vulnerability location. Format locations as workspace-relative markdown links (for example, `[path/to/file.ext#L42](path/to/file.ext#L42)`).
4. Extract the offending code snippet (3–10 lines centered on the vulnerable line) from the source file when the verdict is CONFIRMED or DOWNGRADED.
5. Provide an example fix code snippet demonstrating how to remediate the vulnerability in-place when the verdict is CONFIRMED or DOWNGRADED.
6. Write the justification citing specific file paths and line numbers.
7. Write updated remediation guidance accounting for any existing mitigations found during contradiction search.

## Response Format

When `Domain=rai`, return one `RAI_DEEP_VERIFICATION_V1` record per input finding according to the Finding Formats reference in `security-reviewer-formats`. Do not return a Deep Verification Verdict block for this branch.

When Domain is omitted, return one Deep Verification Verdict block per finding, using the format defined in the Deep Verification Verdict Format section. Include all findings in a single response.

For an omitted Domain, return structured findings including:

* One verdict block per finding with all fields populated.
* Clarifying questions, if any ambiguity prevents a confident verdict for a specific finding.

Do not modify any files in the repository. Do not introduce new findings; only verify the findings provided in the input.

© microsoft · MIT · microsoft/hve-core

Similar subagents

All subagents for Security →
scan-verifier official Anthropic scan-verifier is a Claude Code subagent that challenges one security finding by tracing its evidence in the repository. The Claude Security workflow dispatches it; it is not meant for direct invocation. CX Codex ★ 47,914repo stars finding-discovery official OpenAI finding-discovery is a Codex skill that looks for plausible security findings in code and changes. It runs during finding discovery or after an explicit request to inspect candidate vulnerabilities. CX Codex GP ChatGPT +1 24installs vuln-verifier NYCU-Chung vuln-verifier verifies security findings from code reviews by building targeted reproduction scripts. Helps confirm real flaws and weed out false positives before filing advisories. CX Codex ★ 267repo stars deep-security-scan official openai deep-security-scan is a Claude Code skill that runs deep, multi-pass repository security audits, combining findings until consecutive scans reveal nothing new. CX Codex +1 127installs agent-sdk-verifier-py official Anthropic agent-sdk-verifier-py — a Claude Code subagent that verifies Python applications built on Agent SDK: correct setup, adherence to documentation, and readiness for deployment. Invoked after an application is created or modified. CX Codex ★ 47,914repo stars owasp-security agamm owasp-security — a skill that reviews code and diffs for vulnerabilities against OWASP Top 10:2025, ASVS 5.0, and the LLM and agentic risk lists. Useful before a release. CX Codex +1 2,800installs

From the same set148

The whole set →
gh-code-scanning gh-code-scanning groups open GitHub Code Scanning alerts by rule and sorts them by occurrence count. Use it to inspect a repository’s findings. CX Codex +1 ★ 1,627repo stars privacy-by-design Assesses projects against the 7 Privacy by Design principles, flags data protection gaps, delivers per-principle verdicts, and suggests fixes. CX Codex +1 ★ 1,627repo stars pull-request Prepares, creates, or updates GitHub pull requests using targeted diff preflight, repo templates, and distinct push approval gates. CX Codex +1 ★ 1,627repo stars gitlab Use a Python CLI to inspect and update GitLab merge requests, notes, pipelines, and job logs. It works with GitLab.com and self-managed instances. CX Codex +1 ★ 1,627repo stars planner-identity-base planner-identity-base is a Claude Code rule that provides a shared scaffold for planning agents, with six sequential phases and persistent project state in JSON. CX Codex +1 ★ 1,627repo stars RAI Skill Assessor The RAI Skill Assessor subagent checks a codebase or plan against one Responsible AI framework at a time. Use it to get structured findings and remediation guidance. CX Codex +1 ★ 1,627repo stars rpi-walkthrough rpi-walkthrough walks through code, UI, UX or .copilot-tracking artifacts segment by segment, explaining each block and decision with navigable file and line links. CX Codex +1 ★ 1,627repo stars markdown Defines Markdown conventions and YAML frontmatter requirements across all .md files. Keeps Claude Code aligned with markdownlint rules. CX Codex +1 ★ 1,627repo stars

Project sponsors

Companies that keep this analytics open