> your AI agent picks dependencies from memory; give it dated facts — try starlog.dev ↗ vet your agent's deps ↗ vibe-coding is fine. vibe-importing isn’t. — try starlog.dev ↗ vibe-importing isn’t fine ↗ your agent has never seen your private packages — try starlog.dev ↗ facts for private packages ↗ a linter for the dependencies your AI agent picks — try starlog.dev ↗ a linter for agent deps ↗ whois is redacted, cdns mask the rest — get the real operator — try whoisgeni.us ↗ who really runs that domain ↗ domain attribution that shows its work — full evidence chain — try whoisgeni.us ↗ domain intel w/ evidence ↗

← Back to Articles

WSARTEX: Building an Autonomous AI Pentesting System with Multi-Agent Collaboration

[ View on GitHub ]

WSARTEX: Building an Autonomous AI Pentesting System with Multi-Agent Collaboration

Hook

Most security teams spend 60% of their pentest time on reconnaissance and vulnerability correlation—work that follows deterministic patterns perfect for AI automation. WSARTEX attempts to compress weeks of manual testing into hours of autonomous agent collaboration.

Context

Traditional penetration testing follows a predictable workflow: reconnaissance, vulnerability scanning, exploitation, post-exploitation, and reporting. Yet most organizations treat this as artisanal work, hiring consultants who manually execute the same tool chains (nmap → Nessus → Metasploit) every engagement. Commercial platforms like Pentera and NodeZero emerged to automate this, but they're expensive SaaS products with black-box decision-making.

The rise of tool-use capable LLMs (GPT-4, Claude with function calling) created a new possibility: autonomous agents that can plan attack sequences, interpret tool outputs, and adapt strategies like human pentesters. Projects like PentestGPT proved LLMs could assist with security workflows, but most remained interactive copilots rather than fully autonomous systems. WSARTEX bridges this gap by wrapping the ARTEX agent framework in a pentesting-specific orchestration layer, giving security researchers a self-hosted platform to experiment with multi-agent offensive operations in controlled environments.

Technical Insight

Security Tools

Multi-Agent System

Target & Objectives

Action Requests

ReAct Loop

Tool Invocations

Raw Output

Observations & Next Actions

State Persistence

Updated Context

Task Results

Status & Logs

User/Operator

REST API Layer

Go Backend Orchestrator

Recon Agent

Exploit Agent

Post-Exploit Agent

Norma SDK - ARTEX Engine

LLM Planning Layer

nmap

nuclei

sqlmap

Knowledge Graph - Assets/Vulns

File-based Storage - data/

Next.js Control Panel

System architecture — auto-generated

WSARTEX's architecture centers on a Go backend that orchestrates specialized LLM agents through the bundled 'norma' SDK—a repackaging of the ARTEX autonomous agent framework. Unlike monolithic LLM applications, this uses a multi-agent pattern where distinct agents handle reconnaissance, exploitation, and post-exploitation phases while sharing a common knowledge graph of discovered assets and vulnerabilities.

The agent workflow follows a ReAct (Reasoning + Acting) loop. When you assign a target network, the reconnaissance agent receives an objective like 'Map all live hosts and services in 192.168.1.0/24'. The LLM decomposes this into tool invocations:

// Conceptual representation of agent action execution
type Action struct {
    Tool   string                 // "nmap", "nuclei", "sqlmap"
    Params map[string]interface{} // {"target": "192.168.1.0/24", "flags": "-sV"}
}

type AgentResult struct {
    Output      string   // Raw tool stdout
    Observation string   // LLM interpretation
    NextActions []Action // Dynamically planned follow-ups
}

// Agent executes tool, feeds output back to LLM for interpretation
func (a *Agent) Execute(action Action) (*AgentResult, error) {
    output := executeTool(action.Tool, action.Params)
    
    // LLM interprets output and plans next steps
    observation := a.llm.Analyze(output, a.objective)
    nextActions := a.llm.PlanNext(observation, a.knowledgeGraph)
    
    // Update shared state for other agents
    a.knowledgeGraph.Update(observation)
    
    return &AgentResult{
        Output:      output,
        Observation: observation,
        NextActions: nextActions,
    }, nil
}

The knowledge graph is the system's memory—file-based JSON structures in data/assets/ and data/vulnerabilities/ that persist discovered hosts, open ports, identified vulnerabilities, and exploitation attempts. When the recon agent finds a web server on port 8080, it writes this to the asset graph. The vulnerability scanning agent reads this graph, sees the new service, and autonomously triggers Nuclei templates against it. If a SQL injection is confirmed, the exploitation agent can query the graph for database credentials found elsewhere in the network.

What makes this genuinely multi-agent is the specialization. A recon agent is prompted with context like 'You are a network reconnaissance specialist. Your goal is thorough service enumeration without triggering IDS alerts.' The exploit agent gets 'You are a penetration tester focused on safe exploitation. Verify all findings before attempting exploits. Never target production systems.' This prompt-based role differentiation lets each agent develop appropriate tool-use strategies—the recon agent learns to combine ping sweeps with DNS enumeration, while the exploit agent chains authentication bypasses with privilege escalation.

The Python launcher (start.py) handles the operational complexity of running this stack. It auto-installs Go dependencies, builds the backend, installs Next.js packages, and starts both servers with a single command:

# Simplified launch workflow
def start_system():
    check_dependencies()  # Verify Go, Node, Python installed
    
    # Build Go backend
    subprocess.run(["go", "mod", "download"], cwd="backend")
    subprocess.run(["go", "build", "-o", "wsartex-server"], cwd="backend")
    
    # Build Next.js frontend
    subprocess.run(["npm", "install"], cwd="frontend")
    subprocess.run(["npm", "run", "build"], cwd="frontend")
    
    # Start services
    backend_proc = subprocess.Popen(["./wsartex-server"])
    frontend_proc = subprocess.Popen(["npm", "start"], cwd="frontend")
    
    print("WSARTEX running at http://localhost:3000")
    manage_processes(backend_proc, frontend_proc)

This zero-config approach is intentional. Security researchers often work in airgapped lab environments where Docker registries are blocked and Kubernetes is overkill. A single Python script that handles builds and process management removes friction for practitioners who think in terms of running exploit scripts, not managing container orchestration.

The Next.js frontend provides real-time visibility into agent decision-making. You can watch agents debate whether a potential SQL injection is a false positive, see the tool commands they generate, and intervene if they're heading down unproductive paths. This transparency is critical for research use—you're not just getting pentesting results, you're observing how LLM agents decompose complex security objectives into executable tool chains.

Gotcha

The file-based persistence model is WSARTEX's Achilles heel for anything beyond small lab networks. Every asset discovery, vulnerability finding, and agent decision gets serialized to JSON files in data/ directories. There's no indexing, no relational queries, no transaction guarantees. When you're testing a /24 network with 50 live hosts, this works fine. Scale to a /16 enterprise network with thousands of assets and hundreds of vulnerabilities, and you're doing linear scans through megabytes of JSON to answer questions like 'show me all SQL injection findings on Windows servers.' The system will slow to a crawl, and analyzing results means writing custom parsing scripts instead of SQL queries.

The LLM dependency creates operational fragility. Every agent decision requires API calls to OpenAI, Anthropic, or compatible providers. If you're testing a large network, the token costs add up fast—a thorough reconnaissance phase might burn through 100K tokens interpreting nmap outputs and planning follow-ups. You can't run this offline in truly isolated ranges without hosting your own LLM (Llama, Mistral), which isn't documented. More concerning is the lack of visible safety guardrails. LLMs hallucinate. If an agent hallucinates that 10.0.0.1 is in-scope when it's actually your management network, and the exploit agent fires attacks at it, the code doesn't show obvious validation layers. For a research tool, this is acceptable—you should be running this in disposable VMs. For anything approaching production pentesting, it's a liability. The Chinese-language primary documentation also creates adoption friction for English-speaking teams, though the Go codebase itself appears to use English identifiers.

Verdict

Use WSARTEX if you're a security researcher or red team member who wants to experiment with autonomous pentesting agents in controlled lab environments, values self-hosted deployment over SaaS subscriptions, and can tolerate file-based storage limitations for small-to-medium attack surfaces. It's particularly strong for educational scenarios—teaching students how agents decompose attack chains or prototyping novel agent-tool integrations before hardening them. The zero-config Python launcher and bundled dependencies make it the cleanest starting point for offensive security agent research without wrestling Docker or cloud platforms. Skip if you need production-grade scalability beyond /24 networks, multi-user access control, compliance-friendly audit trails, or truly offline operation without external LLM APIs. The file-based architecture breaks down on large engagements, and the bundled 'norma' SDK being minimally documented creates a trust boundary despite AGPL licensing. For commercial pentesting operations, established platforms like Pentera handle scoping, legal compliance, and result validation far better than any DIY agent system.