How to Integrate Reverse-Skill with Other Tools: A Complete MCP Integration Guide

The reverse-skill framework integrates external security and reverse-engineering tools through a five-layer architecture that uses machine-specific tool discovery, MCP JSON configuration, and a routing matrix to connect AI agents to any CLI utility.

This guide walks through integrating new tools into the reverse-skill repository (zhaoxuya520/reverse-skill), a modular Skill Router that bridges AI agents with local security utilities. Whether you're adding Wireshark, Ghidra, or a custom binary, the framework's standardized pipeline ensures consistent discovery, execution, and reporting.

Understanding the Integration Architecture

Before adding tools, grasp how reverse-skill orchestrates components. The framework separates concerns across five layers, each with dedicated files:

Layer	Purpose	Key Files
Routing	Decides which sub-skill runs based on target type and intent	skills/SKILL.md, skills/routing.md
Bootstrap	Discovers available tools and installs missing dependencies	skills/scripts/refresh-tool-index.sh, kali/scripts/bootstrap-reverse.sh
Tool-index	Machine-specific manifest recording executable presence	skills/tool-index.md (auto-generated)
MCP	Exposes tools as HTTP services for AI agent consumption	README_AI.md (MCP section)
Execution	Scripts that drive concrete tools (Bash, PowerShell, Python)	skills/<skill>/scripts/*
Feedback	Writes outcomes to field-journal and generates reports	field-journal/_index.md, skills/docs-generator/*

The full behavior chain is visualized in [docs/ARCHITECTURE.md](https://github.com/zhaoxuya520/reverse-skill/blob/main/docs/ARCHITECTURE.md) — see the "Bootstrap 自举流程" and "外部 CTF" sections for flow diagrams.

Step 1: Refresh the Tool Index

First, inform reverse-skill what binaries exist on your host. Run the platform-specific refresh script:

# Linux, macOS, or generic Unix

bash skills/scripts/refresh-tool-index.sh

# Kali Linux (uses extended detection)

bash kali/scripts/refresh-tool-index.sh

This script populates skills/tool-index.md with entries like:

| Tool | Available | Path |
|------|-----------|------|
| tshark | yes | /usr/bin/tshark |
| ghidra | no | — |

The bootstrap logic is implemented in kali/scripts/bootstrap-reverse.sh, which also attempts to install missing tools when possible.

Step 2: Configure the MCP Server

The MCP (Multi-Channel Proxy) layer exposes tools as callable services. Create or extend an MCP JSON file that defines how to launch your tool.

For a tshark integration example, place this in your agent's MCP configuration (e.g., .claude/mcp.json or tools/mcp.json):

{
  "mcpServers": {
    "tshark": {
      "command": "tshark",
      "args": [
        "-i", "any",
        "-w", "/tmp/capture_{timestamp}.pcap"
      ],
      "env": {}
    }
  }
}

The JSON format is documented in the MCP Example section of [README_AI.md](https://github.com/zhaoxuya520/reverse-skill/blob/main/README_AI.md). Key fields:

• command: The executable name (must match an entry in tool-index.md)
• args: Default arguments; use {placeholders} for dynamic values
• env: Environment variables injected at runtime

For a complete working example, examine [burp-mcp-full/README.md](https://github.com/zhaoxuya520/reverse-skill/blob/main/burp-mcp-full/README.md), which implements a full MCP module for Burp Suite.

Step 3: Update the Routing Matrix

The router consults skills/routing.md to map user scenarios to MCP servers. Add a clause linking your use case to the new tool:

| Scenario | MCP Server | Sub-skill path |
|----------|-----------|----------------|
| network-capture | tshark | tshark-capture/SKILL.md |
| binary-analysis | radare2 | radare2-decompile/SKILL.md |
| apk-reverse | apktool | apk-reverse/SKILL.md |

This entry tells reverse-skill: when the user requests "network capture," invoke the tshark MCP server and delegate workflow control to tshark-capture/SKILL.md.

Step 4: Create the Sub-Skill Definition

Each tool integration requires a minimal SKILL.md describing the workflow. Create skills/tshark-capture/SKILL.md:

# tshark-capture

## Description

Capture live network traffic using tshark and return the generated pcap file.

## ACTION REQUIRED

1. Invoke the `tshark` MCP server with the provided arguments.
2. Wait for the user-defined duration (default 30s).
3. Stop the capture and retrieve `/tmp/capture_*.pcap`.
4. Store the file path in the report and write a short journal entry.

Reuse patterns from existing sub-skills like radare2/ or apk-reverse/ — the framework expects consistent sections: Description, ACTION REQUIRED, and optionally INPUTS/OUTPUTS.

Step 5: Execute and Verify

With all components in place, an AI agent now follows this chain:

1. Reads RULES.md → SKILL.md → routing.md → tool-index.md
2. Confirms tshark availability in the tool-index
3. Launches the MCP server defined in your JSON
4. Executes the sub-skill workflow
5. Generates a report and appends to field-journal/_index.md

Post-execution, reverse-skill automatically:

• Updates field-journal/_index.md with task outcomes
• Refreshes tool-index.md if tool availability changed
• Outputs a verification checklist (see README_AI.md)

Platform-Specific Bootstrapping

Different environments use dedicated bootstrap scripts:

Platform	Script	Purpose
Generic Linux/macOS	skills/scripts/refresh-tool-index.sh	Core tool detection
Kali Linux	kali/scripts/refresh-tool-index.sh	Extended security tool detection
Windows	skills/scripts/refresh-tool-index.ps1	PowerShell-based discovery

All scripts write to the same skills/tool-index.md format, ensuring cross-platform compatibility.

Summary

Integrating tools with reverse-skill follows a standardized pipeline:

• Refresh the tool-index so the framework knows what's installed
• Configure an MCP JSON entry defining how to launch the tool
• Route scenarios to your tool via skills/routing.md
• Define the sub-skill workflow in a SKILL.md file
• Execute and let the feedback layer handle reporting

This architecture lets any CLI-based security or reverse-engineering utility plug into AI agent workflows with minimal boilerplate.

Frequently Asked Questions

What file formats does reverse-skill use for tool configuration?

Reverse-skill uses Markdown for routing (skills/routing.md), tool manifests (skills/tool-index.md), and sub-skill definitions (SKILL.md). MCP server definitions use JSON files loaded by your AI agent's configuration. All formats are human-readable and version-control friendly.

Can I integrate GUI-only tools like IDA Pro or Ghidra?

Yes, though it requires additional scripting. The burp-mcp-full/ directory demonstrates wrapping a tool with a local HTTP proxy. For GUI tools, create a headless automation script (Python with PyAutoGUI, or Java for Ghidra's scripting API) and expose it through the MCP layer as a command-line wrapper.

How does reverse-skill handle tool installation failures?

The bootstrap scripts in skills/scripts/ and kali/scripts/ attempt package manager installation when tools are missing. If installation fails, the tool is marked available: no in tool-index.md, and routing automatically excludes that MCP server. Check README_AI.md for manual installation fallback procedures.

Where do execution logs and results get stored?

All task outcomes write to field-journal/_index.md with timestamps and file references. Generated artifacts (pcaps, decompiled code, reports) are stored at paths defined in your sub-skill's SKILL.md, typically under field-journal/{task-id}/. The skills/docs-generator/ scripts format these into final deliverables.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}