Introduction

This project, AdaptiveFuzz, presents an LLM-powered multi-agent framework designed to automate the reconnaissance phase of penetration testing. The system emulates the adaptive, step-by-step reasoning of a human red-team operator by moving beyond static scripts. It leverages a team of five specialized agents orchestrated by LangGraph to intelligently plan tasks, execute them using custom tools via the Model Context Protocol (MCP), analyze findings, and propose new strategies. A critical Human-in-the-Loop (HITL) component ensures a human operator retains final approval over the "adaptive" workflow, directing the system's next steps.

This project fulfills the Module 2 requirements for the Agentic AI Developer Certification by demonstrating multi-agent collaboration, advanced tool integration, and orchestration.

The Challenge: Static vs. Adaptive Reconnaissance

Traditional penetration testing often relies on static scripts or manual, predefined patterns. The true skill of a human red-team operator, however, is their adaptive, step-by-step reasoning. They run a tool, analyze the results, form a new hypothesis, and then choose their next tool and target based on those findings.

The goal of AdaptiveFuzz is to emulate this human-centric, adaptive workflow, moving beyond static scripts to create an intelligent assistant for security professionals.

The Solution: An Orchestrated Agent Team

AdaptiveFuzz functions as a team of specialized AI agents. It intelligently plans enumeration tasks, executes them by calling real security tools, analyzes the results, and proposes new strategies. Crucially, it keeps a human operator in the loop for final approval before proceeding.

This entire system is built on two key technologies:

1. LangGraph: The entire multi-agent workflow is orchestrated using LangGraph. Each agent and step in the reconnaissance process is a node in a stateful graph, making the system modular, debuggable, and capable of complex, cyclical reasoning.

2. Model Context Protocol (MCP): MCP serves as the communication bridge that allows the LangGraph agents to interact with the actual security tools. The project uses FastMCP to serve Python-based tools, which the agents can then call to scan targets and gather live information.

Architecture: The Agentic Workflow

The system's logic is defined in code/graph.py and operates as a team of five specialized agents, plus one human control point.

---
config:
  flowchart:
    curve: CARDINAL
---
graph TD;
	__start__([<p>__start__</p>]):::first
	conversational_handler(conversational_handler)
	recon_executor(recon_executor)
	web_analyzer(web_analyzer)
	result_interpreter(result_interpreter)
	strategy_advisor(strategy_advisor)
	human_in_loop(human_in_loop)
	__end__([<p>__end__</p>]):::last
	__start__ --> conversational_handler;
	conversational_handler -. &nbsp;review&nbsp; .-> human_in_loop;
	conversational_handler -. &nbsp;proceed&nbsp; .-> recon_executor;
	human_in_loop -. &nbsp;stop&nbsp; .-> __end__;
	human_in_loop -. &nbsp;continue&nbsp; .-> recon_executor;
	recon_executor --> web_analyzer;
	result_interpreter --> strategy_advisor;
	strategy_advisor --> human_in_loop;
	web_analyzer --> result_interpreter;
	classDef default fill:,line-height:1.2
	classDef first fill-opacity:0
	classDef last fill:

• Conversational Handler: The entry point. This agent receives the high-level goal from the user (e.g., "Scan this target IP for web vulnerabilities") and decomposes it into a list of specific, executable tasks.
• Recon Executor: This agent takes the task list and executes each one by calling the appropriate MCP tools (like port_scanner or banner_grabber) to gather raw data from the target.
• Web Analyzer: The raw tool output (e.g., "Port 80 open, banner: Apache/2.4.18") is passed to this agent. It uses the web_search tool to gather external context, such as identifying service versions or searching for known CVEs.
• Result Interpreter: This agent synthesizes all the information—both the raw scan results and the web search context—into a clean, human-readable list of concise security findings.
• Strategy Advisor: Based on the unified findings, this agent acts like a senior penetration tester. It reviews the situation and proposes exactly three prioritized, strategic next steps to continue the enumeration.

The "Adaptive" Loop: Human-in-the-Loop (HITL)

The process does not auto-run. The three strategies proposed by the Strategy Advisor are presented to the human operator.

This Human-in-the-Loop node is the critical control point. The system pauses its execution (using langgraph.types.interrupt) and waits for the user to choose which strategy to pursue (1, 2, or 3) or to type 'stop' to end the test.

If the user chooses a strategy, the graph routes back to the Recon Executor to run the new tasks. This iterative cycle of Execute -> Analyze -> Strategize -> Get Human Approval is what makes the system truly "adaptive".

Custom Tool Integration

The system's capabilities are extended beyond the LLM's knowledge by integrating three custom tools via FastMCP:

1. port_scanner: A custom tool built with Python's socket library to scan a target IP for a list of open ports.
2. banner_grabber: Connects to open ports to grab service banners, helping to identify running software.
3. web_search: A tool that performs a Google web search using aiohttp to gather external intelligence on findings.

Conclusion

AdaptiveFuzz demonstrates a practical, powerful implementation of a multi-agent system. By combining the stateful orchestration of LangGraph, the real-world tool-use of MCP, and the critical reasoning of a human-in-the-loop, it creates an adaptive framework that effectively assists with the complex, dynamic process of cybersecurity reconnaissance.

You can explore the project here: AdaptiveFuzz on GitHub