Hunt Threat logo

Hunt Threat

Community
dandye
hunt-threat

Conduct proactive, hypothesis-driven threat hunting. Use when performing advanced hunting based on threat intelligence, TTPs, or anomalies. For Tier 3 analysts or dedicated threat hunters. Supports iterative search, pivoting, and comprehensive documentation.

Overview

Publisherdandye
Repositoryai-runbooks
Skill namehunt-threat
Stars
126
Forks
34
Bundled files
Instructions only
LicenseApache-2.0
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • Self-contained

    Everything the model needs lives in the instructions — no extra files to sync.

  • Open source

    Published by dandye on GitHub. Read the source before you install it.

Installation

Install the Hunt Threat AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/dandye/ai-runbooks.git /tmp/ai-runbooks
mkdir -p .claude/skills
cp -r /tmp/ai-runbooks/skills/hunt-threat .claude/skills/hunt-threat
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Hunt Threat in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Hunt Threat on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Hunt Threat is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Advanced Threat Hunting Skill

Conduct proactive, hypothesis-driven threat hunts based on threat intelligence, observed anomalies, or specific TTPs.

Inputs

  • HUNT_HYPOTHESIS - Clear statement of the hunt objective (required)
    • Example: "Suspected DNS tunneling for C2 based on recent actor TTPs"
    • Example: "Anomalous PowerShell execution on critical servers"
    • Example: "Living-off-the-land techniques bypassing EDR"
  • (Optional) RELEVANT_GTI_REPORTS - GTI Collection IDs or report names
  • (Optional) TARGET_SCOPE_QUERY - UDM query to narrow initial scope
  • TIME_FRAME_HOURS - Lookback period (default: 168 = 7 days)
  • (Optional) HUNT_CASE_ID - case for tracking the hunt

Workflow

Step 1: Define Hypothesis & Scope

Clearly articulate:

  • What threat behavior are we looking for?
  • What would evidence of this look like in logs?
  • What systems/users are in scope?
  • What time period is relevant?

Create or identify HUNT_CASE_ID for documentation.

Step 2: Deep Intelligence Analysis

For each relevant GTI report:

gti-mcp.get_collection_report(id=REPORT_ID)
gti-mcp.get_entities_related_to_a_collection(id=REPORT_ID, relationship_name="attack_techniques")
gti-mcp.get_collection_timeline_events(id=REPORT_ID)
gti-mcp.get_collection_mitre_tree(id=REPORT_ID)

Also:

gti-mcp.get_threat_intel(query="Details on specific TTPs")

Step 3: Develop Initial Hunt Queries

Based on hypothesis and intelligence, formulate advanced queries:

SIEM queries:

secops-mcp.search_security_events(
    text="Advanced UDM query targeting specific behaviors",
    hours_back=TIME_FRAME_HOURS
)

BigQuery (for large-scale analysis):

bigquery.execute-query(query="Complex analytical query")

Step 4: Iterative Search & Analysis

Hunt Loop:

  1. Execute queries
  2. Analyze results for outliers, suspicious patterns
  3. Identify leads (suspicious hosts, users, processes, connections)
  4. Refine hypothesis based on findings
  5. Develop new, more targeted queries
  6. Repeat until exhausted or time limit reached

Key questions at each iteration:

  • Does this match our hypothesis?
  • What's the baseline/normal behavior?
  • Are these true anomalies or noise?
  • What should we pivot on next?

Step 5: Advanced Enrichment

For each promising lead:

secops-mcp.lookup_entity(entity_value=LEAD)

GTI enrichment and pivoting:

gti-mcp.get_..._report(identifier=LEAD)
gti-mcp.get_entities_related_to_...(identifier=LEAD)

Check IOC matches:

secops-mcp.get_ioc_matches()

Step 6: Continuous Documentation

Document throughout in HUNT_CASE_ID:

  • Queries used (with results summary)
  • Analysis reasoning
  • Positive and negative findings
  • Pivots and why they were taken

Use /document-in-case for each significant finding.

Step 7: Hunt Report

Use /generate-report with REPORT_TYPE="hunt_summary":

  • Hypothesis and scope
  • Intelligence sources used
  • Queries executed
  • Findings (positive and negative)
  • Recommendations

Step 8: Action Based on Findings

Confirmed Threat Found: → Escalate to Incident Response immediately → Create incident case, hand over evidence

Suspicious Activity (not confirmed): → Recommend enhanced monitoring → Propose new detection rules to Security Engineering

Valuable Insights (no active threat): → Document for future reference → Propose detection improvements

Inconclusive: → Document process and limitations → Note areas for future investigation

Required Outputs

After completing this skill, you MUST report these outputs:

OutputDescription
HUNT_QUERIESUDM queries executed during the hunt
INITIAL_FINDINGSRaw findings from SIEM searches
FINDINGS_TYPECategory: lateral_movement, credential_access, data_exfil, or generic
DISCOVERED_IOCSIOCs extracted from findings (IPs, domains, hashes)
HIGH_CONFIDENCE_IOCSIOCs confirmed malicious via GTI enrichment
THREAT_CONFIRMEDBoolean: true if active threat confirmed, false otherwise

Hunt Hypothesis Templates

TTP-Based:

"Hunt for [MITRE Technique] activity, specifically [observable behavior], targeting [scope] over [timeframe]."

Actor-Based:

"Hunt for [Threat Actor] TTPs including [specific techniques], focusing on [likely targets] based on [intelligence source]."

Anomaly-Based:

"Investigate anomalous [behavior type] observed in [data source], specifically [anomaly description], to determine if malicious."

Example Hunt Queries

DNS Tunneling:

udm
metadata.event_type = "NETWORK_DNS" AND
network.dns.questions.name MATCHES ".*[a-z0-9]{30,}.*" AND
target.hostname NOT IN @known_cdn_domains

Suspicious PowerShell:

udm
metadata.event_type = "PROCESS_LAUNCH" AND
target.process.file.full_path MATCHES ".*powershell.*" AND
target.process.command_line MATCHES ".*(encodedcommand|bypass|hidden).*"

Living-off-the-Land:

udm
metadata.event_type = "PROCESS_LAUNCH" AND
target.process.file.full_path IN @lolbins_list AND
principal.user.userid NOT IN @authorized_admins

Frequently asked questions

What does the Hunt Threat AI skill do?

Conduct proactive, hypothesis-driven threat hunting. Use when performing advanced hunting based on threat intelligence, TTPs, or anomalies. For Tier 3 analysts or dedicated threat hunters. Supports iterative search, pivoting, and comprehensive documentation.

Why use Hunt Threat on TypingMind?

Because you install it once and use it with any model. Hunt Threat is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Hunt Threat in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/dandye/ai-runbooks/tree/main/skills/hunt-threat. TypingMind reads its SKILL.md and installs it as a skill you can enable per chat.

Which AI models can use Hunt Threat?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Hunt Threat?

As many as you like. As long as a model supports skills, you can use Hunt Threat with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Hunt Threat AI skill free?

Yes. It is published on GitHub by dandye under the Apache-2.0 license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇