Provides detection lookup files for enrichment in Elasticsearch, enabling efficient threat detection queries using ES|QL ENRICH.
Provides MCP tools for AI agents (e.g., GitHub Copilot) to query detection lookups for binary risk, parent-child relationships, and MITRE mappings in real-time.
Provides detection lookup files for enrichment in Splunk, enabling efficient lookup operations for threat detection.
Machine-readable detection lookups for SIEM enrichment and AI agents. MCP-native.
Stop regex-matching 200+ binaries. Enrich in one
match()call.
Feed it to your SIEM, your SOAR, your agent, or your LLM.
A collection of structured CSV lookup files purpose-built for:
SIEM enrichment — one match()/lookup/join replaces entire rule categories
AI agent tooling — MCP server included, agents query detection context in real-time
Detection automation — consistent schema, CI-updated, deploy-ready
Related MCP server: contrastapi
File | Entries | OS | Description |
232 | Windows | Living Off The Land Binaries and Scripts — risk-scored, categorized, MITRE-mapped | |
477 | Linux | GTFOBins Unix binaries — shell escape, priv-esc, file ops, MITRE-mapped | |
97 | Both | Expected/suspicious process parent→child relationships for Windows and Linux |
Every lookup file follows:
First column = match key (the field you join on)
Always includes risk or risk_if_unexpected column
Always includes MITRE ATT&CK technique mapping
No nested data — flat columns, pipe-delimited for multi-value
UTF-8, no BOM, Unix line endings, header row always present
CrowdStrike NG-SIEM:
#event_simpleName=ProcessRollup2
| binary := lower(FileName)
| match(file="lolbas_binaries.csv", field=binary, column=filename, include=[categories, mitre_ids, risk])
| risk="high"Splunk:
index=crowdstrike event_simpleName=ProcessRollup2
| rex field=FileName "(?<binary>[^\\\\]+)$"
| lookup lolbas_binaries.csv filename AS binary OUTPUT categories mitre_ids risk
| where risk="high"Elastic (ES|QL):
FROM logs-endpoint.events.process-*
| WHERE event.action == "start"
| ENRICH lolbas-policy ON process.name = filename WITH categories, risk
| WHERE risk == "high"Microsoft Sentinel:
DeviceProcessEvents
| extend binary = tolower(FileName)
| join kind=inner (_GetWatchlist('lolbas_binaries')) on $left.binary == $right.filename
| where risk == "high"See queries/ for full query libraries per platform.
{
"servers": {
"detection-lookups": {
"type": "stdio",
"command": "python",
"args": ["-m", "mcp_server"],
"cwd": "/path/to/agentic-detection-lookups"
}
}
}Then your agent can:
→ detection_lookup_binary("certutil.exe")
← {source: "lolbas", risk: "medium", categories: ["Download"], mitre_ids: ["T1105"]}
→ detection_lookup_binary("python")
← {source: "gtfobins", risk: "high", categories: ["shell", "reverse-shell", ...], mitre_ids: ["T1059"]}
→ detection_check_parent_child("winword.exe", "cmd.exe")
← {expected: false, risk_if_unexpected: "critical", mitre_id: "T1204.002"}Tool | Input | Output |
| filename | Risk, categories, MITRE IDs, source (lolbas/gtfobins) |
| parent, child, os_filter | Expected/suspicious, risk level, triage guidance |
| category, limit, offset | Paginated binaries in that abuse category (cross-platform) |
| technique_id, limit, offset | Paginated binaries mapped to that technique (cross-platform) |
| query, limit | Matches across all lookup data with total/has_more |
| — | All files with row counts and columns |
Lookup | Source | Update Frequency |
LOLBAS binaries | Weekly (automated) |
Python 3.10+
VS Code with GitHub Copilot (for MCP integration)
git clone https://github.com/detection-forge/agentic-detection-lookups.git
cd agentic-detection-lookups
python -m venv .venv
# Windows:
.venv\Scripts\activate
# Linux/macOS:
source .venv/bin/activate
pip install -e .Add to your VS Code User settings (Ctrl+Shift+P → "Preferences: Open User Settings (JSON)") or ~/.vscode/mcp.json:
{
"servers": {
"detection-lookups": {
"type": "stdio",
"command": "/absolute/path/to/.venv/bin/python",
"args": ["-m", "mcp_server"],
"cwd": "/absolute/path/to/agentic-detection-lookups"
}
}
}Windows example:
{ "servers": { "detection-lookups": { "type": "stdio", "command": "C:\\Code\\.venv\\Scripts\\python.exe", "args": ["-m", "mcp_server"], "cwd": "C:\\Code\\agentic-detection-lookups" } } }
Reload VS Code: Ctrl+Shift+P → "Reload Window"
In Copilot Chat (Agent mode):
Is certutil.exe a LOLBAS binary?✅ Returns risk, categories, and MITRE mappings = working!
detection-lookupsThis starts the MCP server on stdio transport (useful for piping JSON-RPC or connecting other MCP clients).
CrowdStrike NG-SIEM: Upload via API or UI (Settings → Lookup Files)
Splunk: Settings → Lookups → Lookup table files → Add new
Elastic: Create enrich index + ingest pipeline
Sentinel: Configuration → Watchlist → Add new
agentic-detection-lookups/
├── lookups/ # The data (CSV files)
│ ├── lolbas_binaries.csv
│ ├── gtfobins.csv
│ └── parent_child_baselines.csv
├── queries/ # Copy-paste detection queries
│ ├── crowdstrike_ngsiem.md
│ ├── splunk.md
│ ├── elastic.md
│ └── microsoft_sentinel.md
├── mcp_server/ # MCP server for AI agents
│ ├── server.py
│ └── __init__.py
├── scripts/ # Update/maintenance scripts
├── LICENSE # Apache 2.0
├── NOTICE
└── pyproject.tomlPRs welcome. See CONTRIBUTING.md for guidelines.
To add a new lookup file:
Follow the schema contract (match key first, include risk + MITRE columns)
Include at least one query example per SIEM platform
Add a tool to the MCP server
Apache 2.0 — See LICENSE and NOTICE.
Built by Gene Kazimiarovich | Part of Detection Forge
Check if a process parent-child relationship is expected or suspicious.
Provide parent and child process filenames (e.g., parent='winword.exe', child='cmd.exe'). Returns whether the relationship is expected, the risk if unexpected, MITRE technique, and triage notes.
| Name | Required | Description | Default |
|---|---|---|---|
| parent | Yes | ||
| child | Yes | ||
| os_filter | No | windows |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description goes beyond the annotations (readOnlyHint=true, destructiveHint=false, idempotentHint=true) by detailing what the tool returns: 'whether the relationship is expected, the risk if unexpected, MITRE technique, and triage notes.' No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise: three sentences with no wasted words. The first sentence states the purpose, the second gives usage guidance, and the third lists the output fields. All information is front-loaded and relevant.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 3-parameter tool with an output schema (not shown but mentioned), the description covers inputs and outputs reasonably well. The only gap is the undocumented 'os_filter' parameter. The description provides enough context for an agent to use the tool effectively in most cases.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description explains the 'parent' and 'child' parameters with an example, which adds meaning beyond the schema (which has no descriptions). However, the 'os_filter' parameter is not mentioned at all, despite being optional with a default. Since schema description coverage is 0%, the description should cover all parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Check if a process parent-child relationship is expected or suspicious.' The verb 'check' combined with the resource 'parent-child relationship' is specific. It is distinct from sibling tools like 'detection_search' or 'detection_list_by_category' which handle listing or searching, not verification of relationships.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says to provide parent and child process filenames, with an example ('parent='winword.exe', child='cmd.exe''). This gives clear context on how to use the tool. However, it does not mention when not to use it or suggest alternatives from the sibling list, such as 'detection_search' for broader queries.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all binaries in a specific abuse category.
LOLBAS categories: Execute, Download, Upload, AWL Bypass, UAC Bypass, Compile, Credentials, Dump, Encode, Reconnaissance. GTFOBins categories: shell, reverse-shell, bind-shell, file-read, file-write, download, upload, library-load, command, inherit, privilege-escalation.
Supports pagination via limit (default 50) and offset (default 0).
| Name | Required | Description | Default |
|---|---|---|---|
| category | Yes | ||
| limit | No | ||
| offset | No |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark the tool as read-only and idempotent. Description adds pagination behavior and category lists, providing useful operational context beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is concise and covers key points, though the category lists are inline in a paragraph; bullet points could improve readability. Still efficient overall.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that output schema exists and annotations cover safety, the description covers input parameters sufficiently. It does not discuss output format but that is handled by the schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so description must compensate. It explains category with example lists and pagination parameters with defaults, but does not explicitly state that category values are restricted to those lists, leaving ambiguity.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool lists binaries by abuse category, with explicit category lists for LOLBAS and GTFOBins. It differentiates from sibling tools like detection_list_by_mitre or detection_search.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for listing binaries in known categories but does not specify when to use this versus alternatives, nor does it provide exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all binaries (LOLBAS + GTFOBins) mapped to a specific MITRE ATT&CK technique.
Provide a technique ID like 'T1218', 'T1059.001', 'T1105', etc. Searching a parent technique (e.g., T1218) also returns sub-techniques (T1218.011). Supports pagination via limit (default 50) and offset (default 0).
| Name | Required | Description | Default |
|---|---|---|---|
| technique_id | Yes | ||
| limit | No | ||
| offset | No |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Description adds behavioral context beyond annotations: pagination support with default limit=50 and offset=0, and sub-technique inclusion. Annotations already indicate read-only, idempotent, non-destructive nature; description complements with operational details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is concise with 5 sentences, each adding value: purpose, parameter format, sub-technique behavior, pagination details. No redundant or unnecessary content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Description covers purpose, parameter usage, behavioral nuances, and pagination. Output schema exists, so return values are not needed. It does not explain domain terms like LOLBAS/GTFOBins, which is acceptable for a specialized tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so description carries full burden. It explains technique_id with examples (T1218, T1059.001), and clarifies limit and offset parameters with defaults. This compensates effectively for missing schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool lists binaries (LOLBAS + GTFOBins) mapped to a MITRE ATT&CK technique. It specifies the verb 'list', the resource 'binaries', and the scope 'by MITRE technique', distinguishing it from siblings like detection_lookup_binary or detection_list_by_category.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Description explains how to use the tool with a technique ID and notes that parent techniques return sub-techniques. It does not explicitly exclude alternatives but provides clear context for when to use this tool compared to siblings like detection_list_by_category or detection_search.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all available lookup files and their metadata (row counts, columns).
Use this tool to discover what datasets are available before querying.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations (readOnlyHint, idempotentHint) already establish safety, and the description adds valuable context about return metadata (row counts, columns). No contradictions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, each earning its place. First states purpose, second provides usage guidance. No fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Tool has no parameters, output schema exists, annotations are thorough. Description adds the remaining 'when to use' context, making it fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters, schema coverage 100%. Baseline is 4; description adds nothing needed for parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states verb 'list' and resource 'all available lookup files' with specific metadata (row counts, columns). Differentiates from filtered sibling list tools by implying completeness.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly tells agent to use this 'before querying', providing clear context. Lacks explicit when-not-to-use or naming sibling alternatives, but context is sufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Check if a binary is a known LOLBAS (Windows) or GTFOBins (Linux) living-off-the-land binary.
Provide the filename (e.g., 'certutil.exe', 'curl', 'python'). Returns risk level, abuse categories, MITRE ATT&CK technique IDs, description, and source. Searches both LOLBAS (Windows) and GTFOBins (Linux) datasets. If not found in either, returns {found: false} with a suggestion.
| Name | Required | Description | Default |
|---|---|---|---|
| filename | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds valuable behavioral context: it searches both LOLBAS (Windows) and GTFOBins (Linux) datasets, returns risk level, abuse categories, MITRE IDs, and a suggestion if not found. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise (5 sentences), well-structured, and front-loaded with the main purpose. Every sentence adds necessary information without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given one parameter, clear explanation, existing output schema, and annotations covering safety, the description is fully complete for an agent to understand and invoke the tool correctly. Siblings are clearly different.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With schema description coverage at 0%, the description compensates by explaining the parameter 'filename' with examples like 'certutil.exe', 'curl', 'python'. It clarifies what constitutes a valid input, adding meaning beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool checks if a binary is a known LOLBAS or GTFOBins binary, using the verb 'Check' and specifying the resource ('binary') and context ('living-off-the-land'). It distinguishes itself from siblings like 'detection_check_parent_child' by focusing on binary lookup.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidance: provide a filename (e.g., 'certutil.exe', 'curl', 'python'). It explains what happens if found or not found. However, it does not explicitly mention when not to use or alternative tools, so it's slightly less than perfect.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search across all lookup files for a text match.
Searches filename, description, categories, MITRE IDs, and notes fields
across LOLBAS, GTFOBins, and parent-child baselines.
Returns up to limit results (default 20).
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | ||
| limit | No |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare readonly, nondestructive, idempotent. Description adds that it searches specific fields and returns up to `limit` results. No contradictions. The description provides useful behavioral context beyond annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two brief paragraphs with no filler. Front-loaded with the core action, then details. Every sentence contributes.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 2 parameters and an output schema, this description covers the essential behavior. It could mention read-only nature, but annotations already do. Complete enough for this tool's complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so description must compensate. It adds meaning to `limit` by stating default 20. `query` is only described implicitly as the text to match. Minimal but adequate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it searches for text matches across all lookup files, specifying the fields (filename, description, categories, MITRE IDs, notes) and sources (LOLBAS, GTFOBins, parent-child baselines). This clearly distinguishes it from sibling tools like detection_list_by_category and detection_list_by_mitre.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies this is the general search tool, while siblings are more specific in scope. However, it lacks explicit 'when to use' or 'when not to use' guidance, though the context makes it clear enough.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.1.0detection_check_parent_childdetection_list_by_categorydetection_list_by_mitredetection_list_lookupsdetection_lookup_binarydetection_searchMost tools have distinct purposes (e.g., check parent-child, search, list lookups). However, 'detection_list_by_category' and 'detection_list_by_mitre' both list binaries, which could cause confusion if descriptions aren't read carefully.
All tools start with 'detection_' and use snake_case with verb-noun or verb-preposition-noun patterns. The verbs are consistent (list, check, lookup, search), though 'list_by_category' and 'list_by_mitre' are not strictly verb-noun.
6 tools is well-scoped for a detection lookups server. It covers essential querying capabilities without being overwhelming or too sparse.
The set covers listing, searching, and checking binaries and parent-child relationships. Minor gaps exist, such as no direct tool for retrieving technique details without listing all binaries, but core workflows are supported.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
55 tools, 7 Resources, Sigma rules, email SPF/DMARC, MITRE, CVE/KEV, risk_score. No key.
Real-time threat intel for AI agents: 890K+ IOCs incl. prompt-injection & AI-skill threats
Real-time CVE, exploit, and vulnerability intelligence for AI assistants (350K+ CVEs, 115K+ PoCs)
CVE lookups (NVD) and dependency-manifest audits (OSV) for AI agents. No API keys.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/detection-forge/agentic-detection-lookups'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
