Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@sift-forensic-mcp investigate the VANKO disk image"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Autonomous incident response agent that mounts a 119 GB forensic disk image, hunts malware and anti-forensics through 18 MCP tools on a SIFT Workstation VM, and writes a courtroom-ready report — with no human in the loop.
Demo video: https://youtu.be/ySjuSR9AP3Q
License: MIT
Architecture pattern: Custom MCP Server
The agent receives a single prompt ("investigate the VANKO disk image") and autonomously:
Mounts the EWF forensic image read-only via ewfmount + ntfs-3g
Enumerates users, recent files, and installed software
Scans for suspicious executables in %TEMP%, %AppData%, and Downloads
Parses the Windows registry for persistence mechanisms
Extracts and correlates Windows Event Log logon events
Runs YARA malware signatures across the image
Identifies Prefetch artifacts proving anti-forensic tool execution
Produces findings/findings_report.json with confidence-scored IOCs
On the VANKO case it found 8 confirmed findings including WiFi packet capture, evidence destruction (SDelete), an encrypted volume (VeraCrypt FORMAT confirmed), a typosquatted RAT, and identified the subject as anthony.vanko@gmail.com.
Related MCP server: Sift MCP (Docker edition)
┌──────────────────────────────────────────────────────────┐
│ Windows Host (analyst workstation) │
│ │
│ orchestrator.py ←→ gpt-5.4-mini (OpenAI-compat API) │
│ │ │
│ sift-forensic-mcp (18 MCP tools, stdio transport) │
│ │ asyncssh (TCP 22) │
└────────┼─────────────────────────────────────────────────┘
│
┌────────▼─────────────────────────────────────────────────┐
│ SIFT Workstation 2026 VM (Ubuntu 22.04, VMware NAT) │
│ │
│ /cases/VANKO/surface_physical.E01 │
│ ewfmount → /mnt/ewf/ewf1 │
│ kpartx → /dev/mapper/loop0p3 │
│ ntfs-3g → /mnt/windows/ (READ-ONLY) │
│ │
│ SIFT tools: ewfmount, log2timeline, yara, │
│ regripper, python-evtx, strings, file │
└──────────────────────────────────────────────────────────┘See docs/architecture.md for the full tool inventory and security boundary breakdown.
Windows 10/11 host with VMware Workstation Pro 17+
Python 3.10+
OpenAI-compatible API key (or set OPENAI_BASE_URL to a local endpoint)
~150 GB free disk space (119 GB evidence + SIFT VM)
8 GB+ RAM (16 GB recommended)
git clone https://github.com/OLGTX303/find-evil-sift-agent
cd find-evil-sift-agent
pip install -e .$ovftool = "C:\Program Files (x86)\VMware\VMware Workstation\OVFTool\ovftool.exe"
& $ovftool --acceptAllEulas --name="SIFT-2026" sift-2026-04-22.ova F:\SIFT-VM\find\VANKO\surface_physical.E01 (through .E21)
find\VANKO\vanko-c-drive.CYLR.7zpython setup_sift_vm.py
# Starts the VM, enables SSH, copies evidence — prints the VM IP at the end$env:OPENAI_API_KEY = "sk-..."
$env:OPENAI_BASE_URL = "https://api.openai.com/v1" # or your endpoint
$env:SIFT_HOST = "192.168.x.x" # from setup_sift_vm.py
$env:SIFT_PORT = "22"
$env:SIFT_USER = "sansforensics"
$env:SIFT_PASS = "forensics"
$env:EVIDENCE_DIR = "/cases/VANKO"python orchestrator.py --output-dir ./findingsThe agent prints reasoning and tool calls to stderr in real time.
Investigation takes 15–30 minutes (log2timeline on 119 GB runs in background).
# Structured findings report
cat findings/findings_report.json
# Full timestamped audit trail
cat findings/agent_execution_log.jsonl# Register the MCP server in Claude Code
claude mcp add sift-forensic \
-e SIFT_HOST=192.168.x.x \
-e SIFT_PORT=22 \
-e SIFT_USER=sansforensics \
-e SIFT_PASS=forensics \
-- sift-mcp
# Then in Claude Code:
# "Mount the VANKO image and find evil"sift-agent/
├── orchestrator.py ← Autonomous IR agent (gpt-5.4-mini)
├── setup_sift_vm.py ← One-time VM setup
├── pyproject.toml
├── LICENSE ← MIT
├── src/sift_mcp/
│ ├── server.py ← MCP server (stdio transport)
│ ├── tools.py ← 18 forensic tool implementations
│ └── ssh_client.py ← asyncssh helper with sudo support
├── findings/
│ ├── findings_report.json ← Structured IOC report
│ └── agent_execution_log.jsonl ← Full timestamped audit trail
├── demo/
│ ├── demo_find_evil.mp4 ← Narrated demo video (local copy)
│ ├── mcp_session.json ← Real captured tool output
│ └── cover_3x2.png ← Devpost thumbnail (1200×800)
└── docs/
├── architecture.md ← Component diagram + security boundaries
├── accuracy_report.md ← Finding accuracy + false positive analysis
├── dataset.md ← Evidence dataset documentation
└── try-it-out.md ← Judges guideDocument | Contents |
Component diagram, tool inventory, security boundaries, guardrails | |
8 findings vs ground truth, false positives, evidence integrity | |
VANKO case dataset, provenance, integrity hashes | |
Step-by-step judges guide with troubleshooting |
MIT — see LICENSE.
Check hashes against local NSRL/malware hash database.
| Name | Required | Description | Default |
|---|---|---|---|
| hashes | Yes | List of MD5/SHA256 hashes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose all behavioral traits. It only says 'check against database', not whether it modifies state, returns match details, or requires special permissions. Missing important context for an agent.
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?
Single, well-structured sentence with no wasted words. Front-loaded with the core verb and purpose.
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?
Simple tool, but no output schema exists, and the description omits what the output looks like (e.g., boolean match result, list of matched hashes). Adequate for a basic check but could be more informative.
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 100% with a clear description for the hashes parameter. The tool description adds no further parameter semantics, so baseline of 3 applies.
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 action: checking hashes against a specific database (NSRL/malware). The tool name reinforces this, and it is distinct from siblings like hash_file (which computes hashes) and yara_scan (which uses YARA rules).
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?
No guidance on when to use this tool versus alternatives. Does not mention when this lookup is preferred over other hash-related tools, nor does it specify prerequisites or expected hash types beyond what's in the schema.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read strings from a file on the mounted image (first 4KB).
| Name | Required | Description | Default |
|---|---|---|---|
| remote_path | Yes | Absolute path to file on mounted image |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Description clearly discloses the 4KB limit, which is critical behavioral information. Without annotations, it implicitly indicates a read-only operation, though it does not explicitly state the absence of side effects.
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?
Single sentence, front-loaded with verb and resource, no wasted words.
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?
The description lacks information about the output format or return value (e.g., list of strings, raw content). With no output schema, this omission reduces completeness for a simple 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 coverage is 100%, so baseline is 3. Description adds value by specifying the action ('Read strings') and the 4KB constraint, which is not present in the 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?
Description specifies the verb 'Read strings', the resource 'file on mounted image', and a clear constraint 'first 4KB', which distinguishes it from sibling tools like hash_file or yara_scan.
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?
No explicit guidance on when to use this tool vs alternatives. The description implies its use for extracting strings from files, but does not mention when not to use it or alternative tools for other purposes.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Extract prefetch files, hosts file, browser history paths.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears full responsibility for behavioral disclosure. It fails to mention whether the tool modifies the file system, requires admin rights, outputs raw text or structured data, or handles missing artifacts. The behavioral traits are largely opaque.
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 a single sentence with no fluff. It is front-loaded with the verb and resource list. Every word earns its place.
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 zero parameters and no output schema, the description is minimally adequate but lacks details on how 'browser history paths' are identified or what the output looks like. For a forensics tool, more context (e.g., supported browsers, file sources) would improve completeness.
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 tool has zero parameters, and schema coverage is 100% (empty). The description adds meaning by enumerating the artifacts extracted ('prefetch files, hosts file, browser history paths'), which is useful beyond the schema. Per rubric, 0 parameters baseline is 4, and this is met.
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 extracts specific artifacts: prefetch files, hosts file, and browser history paths. It uses a specific verb ('Extract') and lists the resources, but it does not differentiate from sibling tools like 'extract_file' or 'parse_evtx'.
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 no guidance on when to use this tool versus alternatives. With 18 sibling tools including other extractors and parsers, the description lacks any context about prerequisites, suitable scenarios, or when to avoid this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Find executables in anomalous locations: Temp dirs, user AppData, ProgramData.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It only states what the tool finds, but does not disclose whether it is read-only, what operations it performs (e.g., scanning file system), or any side effects. The agent cannot infer safety or resource usage.
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 a single sentence that is entirely relevant and front-loaded with the core purpose. Every word adds value, with no filler or 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?
The tool has no output schema and no annotations. The description does not indicate what the output looks like (e.g., list of file paths, formatted report) or any performance considerations. Given the context of sibling tools, more information would help an agent decide whether to use this tool first.
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 tool has zero parameters, so no additional parameter information is needed. The description does not mention parameters, but the schema is already complete (empty). Per baseline guidelines, a score of 4 is appropriate for a tool with no 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 verb 'Find' and the resource 'executables in anomalous locations', listing specific examples like Temp dirs, user AppData, ProgramData. It differentiates from sibling tools such as check_known_malware_hashes and yara_scan, which focus on different aspects like hash lookup or signature scanning.
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 no guidance on when to use this tool versus alternatives. It does not mention prerequisites, when-not to use, or how it fits into a workflow with sibling tools like check_known_malware_hashes or yara_scan.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Extract logon/logoff events (4624, 4625, 4634) from Security.evtx.
| Name | Required | Description | Default |
|---|---|---|---|
| top_n | No | Max events (default 30) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully disclose behavior. It does not state whether the tool reads Security.evtx in a non-destructive manner, whether admin privileges are required, or what happens if the file is missing. The term 'Extract' implies a read operation, but details about side effects or dependencies are absent.
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 a single sentence that succinctly conveys the core purpose. It is front-loaded with the action and specific event IDs, and contains no unnecessary words or information.
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 the lack of output schema, the description should indicate what the tool returns (e.g., a list of event records with fields). It does not mention the output format, whether results include timestamps, users, or other fields. The tool's place among siblings is clear, but the functional completeness is lacking.
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 100% (top_n is described as 'Max events (default 30)'). The tool description does not add any additional meaning beyond the schema, such as how the parameter affects the output or acceptable ranges. Baseline score of 3 is appropriate for high coverage without enrichment.
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 action ('Extract'), the resource ('logon/logoff events from Security.evtx'), and the specific event IDs (4624, 4625, 4634). It distinguishes from sibling tools like parse_evtx (broader) and run_log2timeline (timeline analysis) by focusing narrowly on these three event types.
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 no guidance on when to use this tool versus alternatives. For instance, it doesn't mention that parse_evtx is better for arbitrary event log queries, or that run_log2timeline is for timeline generation. There are no excluded scenarios or prerequisites (e.g., requires Security.evtx to be available).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Extract Run/RunOnce autostart registry keys from all user hives.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose any behavioral traits (e.g., read-only, performance, required privileges) beyond the implicit extraction; it lacks details about side effects or system impact.
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?
Single sentence is concise and front-loaded with the key action and resource, containing no unnecessary words.
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 parameterless tool with no output schema, the description adequately explains what it does; however, it could mention the return format or indicate that it is read-only to enhance completeness.
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 zero parameters, the baseline is 4; the description adds no parameter information, but there are none to document, so it meets the baseline.
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 verb 'Extract' and the specific resource 'Run/RunOnce autostart registry keys from all user hives', which is distinct from sibling tools like 'parse_registry' or 'find_suspicious_executables'.
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?
No guidance on when to use this tool versus alternatives such as 'parse_registry' or 'check_known_malware_hashes'; the description implies it extracts persistence keys but does not specify scenarios or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Extract OS version, hostname, timezone from the mounted image.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden for behavioral disclosure. It fails to mention if the operation is read-only, what happens if the image is not mounted, or any side effects.
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 a single, clear sentence that front-loads the purpose with no unnecessary words.
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?
The description omits details about return format or prerequisites. Given no output schema, the description should clarify how results are presented.
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?
There are no parameters, and schema coverage is 100%. The description does not need to add parameter detail, and it correctly implies the tool takes no input.
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 extracts OS version, hostname, and timezone from a mounted image, using a specific verb and resource. However, it does not differentiate from sibling tools like extract_file or extract_network_artifacts.
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?
No guidance is provided on when to use this tool instead of others. The description simply states what it does without contextual recommendations or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Check if log2timeline is running; return last log lines.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses two key behaviors: checking if running and returning log lines. While it does not detail edge cases or failure modes, the simplicity of the tool (0 parameters) makes this adequate.
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 highly concise, comprising two clear clauses with no wasted words. The main purpose is front-loaded, immediately stating what the tool checks.
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 the tool's low complexity (0 parameters, no output schema), the description provides the essential information: what it checks and what it returns. It lacks details on output format or potential error states, but is largely sufficient for the agent.
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?
There are no parameters, so schema coverage is 100%. The description does not need to add parameter details; the baseline of 4 is appropriate as it provides no misleading info.
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 identifies the tool's purpose: checking if log2timeline is running and returning last log lines. It uses a specific verb ('check') and resource ('log2timeline' status), and distinguishes itself from the sibling tool 'run_log2timeline' which is for executing the tool.
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 monitoring status but does not explicitly state when to use this tool versus alternatives like 'run_log2timeline'. There is no guidance on when not to use it or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Compute MD5 and SHA256 hash of a file on the mounted image.
| Name | Required | Description | Default |
|---|---|---|---|
| remote_path | Yes | Path to file |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must carry burden. States it computes hashes 'on the mounted image', implying non-destructive read but does not explicitly confirm no side effects.
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?
Single sentence with no unnecessary words. Concisely conveys the tool's function.
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 the simplicity (1 param, no output schema), the description is adequate for an agent to understand what the tool does and how to use it.
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 100% with 'Path to file'. Description adds no further detail beyond the schema's parameter description.
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 specifies the action 'Compute' and the outputs 'MD5 and SHA256 hash', distinguishing it from sibling tools that check hashes or perform other operations.
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?
No guidance on when to use this tool versus alternatives like check_known_malware_hashes. Does not mention prerequisites or when not to use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List recently accessed files (LNK files) for a user.
| Name | Required | Description | Default |
|---|---|---|---|
| username | No | Windows username (omit for all users) | |
| count | No | Max results (default 50) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, and the description only states the basic function without disclosing behavioral traits such as authentication requirements, scope limitations, or side effects.
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?
Single, clear sentence with no unnecessary words; front-loaded with verb and resource.
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?
No output schema and no annotations; the description fails to explain the return format or what fields are included, which is needed for a listing 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 coverage is 100%, so baseline is 3. The description adds value by specifying 'LNK files', which clarifies the file type beyond the parameter 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?
The description clearly states the tool lists recently accessed files (LNK files) for a user, with a specific verb and resource that distinguishes it from sibling tools like extract_file or hash_file.
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?
No guidance on when to use this tool versus alternatives like get_logon_events or find_suspicious_executables, nor any prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List Windows user accounts discovered in the image.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description only states the basic function without any behavioral traits such as authentication needs, side effects, or output scope. Since no annotations are provided, the description carries full burden but fails to disclose whether the operation is read-only or what data is returned.
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 a single concise sentence that is front-loaded with the core action. However, it could be slightly more informative without becoming verbose.
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 the absence of annotations and output schema, the description is adequate for a simple tool with no parameters, but it omits useful context such as whether the tool returns local or domain users, or if it requires prior processing steps.
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 input schema has zero parameters, so no parameter documentation is needed. The description adds no parameter info, but baseline for 0 parameters is 4.
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 verb 'list' and the resource 'Windows user accounts discovered in the image', making the purpose unambiguous. It naturally distinguishes from sibling tools like check_known_malware_hashes or extract_file, which focus on different artifacts.
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?
No guidance is provided on when to use this tool versus alternatives. The description lacks any context about prerequisites (e.g., whether the image must be mounted) or when listing users is appropriate relative to other forensic steps.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Mount the E01 forensic image using ewfmount + kpartx. Required before any file-system analysis.
| Name | Required | Description | Default |
|---|---|---|---|
| image_path | No | Path to .E01 file on SIFT VM (optional, uses default) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not mention side effects, permissions, mount location, cleanup responsibilities, or whether the operation is read-only. This leaves significant gaps for an agent.
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 two sentences, each providing essential information. The first sentence states the action and tools, the second states the prerequisite. No unnecessary words.
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 no output schema, the description should clarify what happens upon success (e.g., mount points become available) and mention that unmounting is needed later. It lacks these details, making it somewhat incomplete for the workflow context.
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 schema already describes the single parameter (image_path) with 100% coverage, including its optionality and default behavior. The tool description adds no additional meaning beyond the schema, so a baseline score of 3 is appropriate.
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 action (Mount), the resource (E01 forensic image), and the specific tools used (ewfmount + kpartx). It also indicates that it is a prerequisite for file-system analysis, which distinguishes it from sibling tools like unmount_image.
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 says 'Required before any file-system analysis,' providing clear context on when to use this tool. It implies that it should be used before analysis tools, though it does not explicitly exclude other uses or mention when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Parse a Windows EVTX event log file.
| Name | Required | Description | Default |
|---|---|---|---|
| evtx_path | Yes | Path to .evtx file | |
| event_ids | No | Filter to specific Event IDs (optional) | |
| top_n | No | Max events (default 50) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits, but it only says 'Parse'. It does not specify whether the operation is read-only, if it requires administrative privileges, or what side effects occur. The agent lacks critical context about safety and behavior.
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 a single concise sentence with no wasted words. It effectively communicates the core action and resource, though additional detail would be beneficial. Structure is minimal but functional.
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 the absence of an output schema and annotations, the description should compensate by explaining the parse behavior, output format, and limitations. It fails to do so, leaving the agent with incomplete context for effective tool selection.
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 100%, so the input schema already documents all parameters. The description adds no extra meaning beyond the parameter names and types, so a baseline score of 3 is appropriate.
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 action ('Parse') and the resource ('Windows EVTX event log file'), making the tool's purpose unambiguous. It distinguishes from sibling tools that deal with other forensic operations.
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 no guidance on when to use this tool versus alternatives. It does not mention scenarios, prerequisites, or when not to use it, leaving the agent to infer based on the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Parse a Windows registry hive. Optionally navigate to a specific key.
| Name | Required | Description | Default |
|---|---|---|---|
| hive_path | Yes | Path to hive file (NTUSER.DAT, SYSTEM, etc.) | |
| key_path | No | Registry key path within hive (optional) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description must disclose behavioral traits. It only states the action without explaining whether it reads or modifies data, required permissions, output format, or side effects. This is insufficient for informed agent decision-making.
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 two sentences long with no unnecessary words. It is front-loaded and efficiently communicates the core action.
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 no output schema and no annotations, the description fails to specify the tool's return format, behavior on errors, or whether it is read-only. For a forensic tool interacting with sensitive hive files, this is a notable gap.
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 100%, so the schema already documents both parameters. The description adds minimal value by framing the overall action ('Parse a Windows registry hive') but does not elaborate on parameter semantics beyond what the schema provides. Baseline score of 3 is appropriate.
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 parses a Windows registry hive and optionally navigates to a key, which is a specific verb-resource combination. It distinguishes from siblings focused on other forensic artifacts (e.g., parse_evtx, yara_scan).
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?
No guidance on when to use this tool versus siblings like get_run_keys or list_users that also operate on registry data. The description provides no context about prerequisites or alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Start log2timeline timeline creation (long-running). Poll with get_timeline_status.
| Name | Required | Description | Default |
|---|---|---|---|
| output_file | No | Path for .plaso output file | |
| partition | No | Block device of Windows partition |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description carries the behavioral burden. It discloses the tool is long-running and async, but does not detail side effects, resource usage, or concurrency behavior.
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, no fluff. Front-loads the main action and immediately follows with crucial polling instruction.
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 tool with 2 params and no output schema, the description covers basic purpose and async nature. However, it omits what constitutes a valid output file path, partition format, or error handling.
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 100% (both parameters have clear descriptions). The tool description adds no extra parameter information, so baseline score of 3 is appropriate.
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 starts log2timeline timeline creation, a specific action on a specific resource. It distinguishes from sibling get_timeline_status by indicating polling for status.
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 tells the agent to poll with get_timeline_status, indicating when to use this tool (to start) and when to use a sibling (to check status). It hints at long-running nature, though lacks explicit when-not-to-use or alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Query the plaso timeline. Returns events sorted by time.
| Name | Required | Description | Default |
|---|---|---|---|
| filter_query | No | e.g. 'date > 2016-10-01 AND date < 2016-11-05' | |
| top_n | No | Max events to return (default 100) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided. Description only mentions sorting by time but does not disclose if the tool is read-only, performance characteristics, or side effects. Minimal behavioral context beyond the obvious.
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?
Single sentence with key information front-loaded. Efficient but could include a brief note on parameter usage without sacrificing brevity.
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?
Adequate for a simple query tool with two optional parameters. However, no output schema or mention of return format limits completeness. With only 2 params, more usage context would be helpful.
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 covers 100% of parameters with descriptions. The description adds no additional meaning beyond what the schema provides, so baseline 3 is appropriate.
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 it queries the plaso timeline and returns events sorted by time. It differentiates from sibling tools like run_log2timeline (which creates timelines) but does not explicitly mention this distinction.
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?
No guidance on when to use this tool versus alternatives (e.g., get_timeline_status for checking status). No context on prerequisites or typical use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Copy evidence to SIFT VM and verify. Call this first.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description must disclose behavioral traits. It states copying and verification but omits side effects (e.g., whether original data is modified, idempotency, or retry behavior), leaving significant gaps for safe invocation.
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 two sentences, immediately front-loading the action and ordering. Every word earns its place 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?
For a simple zero-parameter setup tool, the description covers purpose and usage order. However, it could briefly mention what 'verify' entails or that successful setup is a prerequisite for sibling tools.
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 zero parameters and 100% schema coverage, the baseline is 4. The description does not need to add parameter details, and no additional meaning is required.
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 action (copy evidence to SIFT VM and verify) and establishes it as the first step among sibling analysis tools, making its purpose unambiguous.
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 instruction 'Call this first' provides explicit ordering, but there is no mention of when not to use or alternative tools. Since the sibling tools are all downstream analysis, the guidance is clear but lacks exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Unmount the forensic image cleanly after analysis.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description is the sole source of behavioral information. The term 'cleanly' hints at safe and proper unmounting, but it does not disclose potential side effects (e.g., behavior if the image is still in use, whether it is idempotent, or error conditions). This leaves some ambiguity for a destructive operation.
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 a single sentence that conveys the essential purpose without any extraneous words. It is front-loaded with the action and resource, and every word serves a purpose. Perfect conciseness.
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 tool with no parameters and no output schema, the description provides sufficient context: it tells what the tool does and when to use it ('after analysis'). It could mention that it is the counterpart to mount_image or specify behavior if called multiple times, but the current description is largely adequate for a simple operation.
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 tool has zero parameters, so the input schema is trivially complete. With schema coverage at 100%, the description does not need to add parameter details. The baseline for zero parameters is 4, and the description meets that without requiring additional semantic explanation.
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 specifies the action 'Unmount' and the resource 'forensic image', with additional context 'cleanly after analysis'. The tool name and description together uniquely identify its purpose, distinguishing it from sibling tools like mount_image.
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 phrase 'after analysis' provides a clear timing guideline for when to use this tool. While it does not explicitly exclude use before mounting or list alternatives, the sibling tool mount_image serves as the counterpart, making the usage context evident.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Run YARA malware detection rules against a path in the mounted image.
| Name | Required | Description | Default |
|---|---|---|---|
| scan_path | No | Path to scan (default: /mnt) | |
| rules_dir | No | Directory with .yar rule files |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, and description does not disclose side effects, auth requirements, or whether it modifies the image. Lacks behavioral context beyond the basic action.
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?
Single sentence, efficient, no fluff. Could benefit from slight expansion but remains concise.
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?
Minimal description for a simple tool with 2 optional parameters and no output schema. Lacks usage guidelines and behavioral context.
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 100% with parameter descriptions, but description adds no extra meaning beyond default values and file extensions.
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 'Run YARA malware detection rules against a path in the mounted image', specifying the verb and resource, and distinguishing from sister tools like hash-based detection.
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?
No guidance on when to use this tool vs alternatives such as check_known_malware_hashes or find_suspicious_executables. No when-not-to-use or prerequisites mentioned.
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.
v0.1.0check_known_malware_hashesextract_fileextract_network_artifactsfind_suspicious_executablesget_logon_eventsget_run_keysget_system_infoget_timeline_statushash_filelist_recent_fileslist_usersmount_imageparse_evtxparse_registryrun_log2timelinerun_psortsetup_evidenceunmount_imageyara_scanScored across 19 tools
Tools are largely distinct, but some overlap exists: parse_evtx and get_logon_events both deal with EVTX files, and check_known_malware_hashes and yara_scan both target malware detection. However, descriptions clarify different contexts.
Most tools follow a consistent snake_case verb_noun pattern (e.g., mount_image, parse_evtx). The exception is yara_scan (noun_verb) which breaks the pattern slightly. Overall, naming is predictable.
19 tools cover a comprehensive forensic workflow without being overwhelming. Each tool serves a clear purpose in the analysis pipeline, from evidence setup to unmounting.
The tool set covers the core forensic workflow: evidence setup, mounting, system info, user analysis, artifact extraction, timeline creation, and malware scanning. Missing some advanced features like file carving or deep file system recovery, but it's adequate for typical investigations.
PDF, photo, email, and file comparison evidence checks with plain-language reports.
Sourced software, security and AI evidence, plus scoped requests for specialist agent help.
Independent AI-agent reviews: trust checks, evidence scorecards, incident registry, recommendations.
Machine-native utility network: verified evidence services for autonomous agents.
