> 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

ScopeWeaver: Multi-Agent Penetration Testing with Asset-Filtered LLM Orchestration

[ View on GitHub ]

ScopeWeaver: Multi-Agent Penetration Testing with Asset-Filtered LLM Orchestration

Hook

ScopeWeaver's asset allow/block rules don't prevent your AI agents from attacking out-of-scope targets—they just stop findings from reaching your database. If you're expecting network sandboxing, you're about to have a very bad day.

Context

Penetration testing workflows have always struggled with the same bottleneck: human analysts spend 70% of their time on reconnaissance drudgework—enumerating subdomains, probing ports, identifying technologies—before they can focus on actual exploitation. Tools like Metasploit and Burp Suite excel at weaponization and manual testing but still require constant human direction. The first wave of automation (Nuclei, AutoRecon) sped up scanning but couldn't make intelligent decisions about what to investigate next.

LLM-powered agents promised to bridge this gap by combining contextual reasoning with tool execution, but most implementations (AutoGPT, PentestGPT) treat security testing as an afterthought—they lack asset management, finding correlation, or approval workflows that match real engagement requirements. ARTEX emerged as a purpose-built autonomous pentest orchestrator, and ScopeWeaver is its multilingual fork, adding English and Korean localization plus integration with ScopeSentry (an asset reconnaissance platform). The value proposition: point AI agents at a scope, let them explore autonomously, and get structured findings in your preferred language without babysitting every API call.

Technical Insight

Agent Execution

Create Task + Lang Pref

Persist State

Enqueue

Spawn

Prompt + Context

Reasoning

WebFetch/Bash

Allowed Assets Only

Network Calls Succeed

Out-of-Scope Blocked at Write

Asset Sync

Resume Tasks

Language Preserved

Serve Results

Next.js Frontend

Embedded Static

Go HTTP Server

Supervisor-Managed

PostgreSQL

Tasks & Findings

LLM Providers

Anthropic/OpenAI/Ollama

Task Queue

Language-Aware

Agent Runtime

Tool Calls

Asset Filter

DB Write Gate

ScopeSentry

Recon Import

System architecture — auto-generated

ScopeWeaver's architecture revolves around a supervisor-managed Go binary with an embedded Next.js frontend (built using the embedui tag) that communicates with PostgreSQL for durable state. Tasks created via HTTP include a language preference field that persists across restarts, ensuring agent output consistency even after process crashes. The multi-tier language resolution chain—request header → Accept-Language → cookie → server default—means you can start a Korean-language reconnaissance task, bounce the server for updates, and resume with agent prompts still rendering in Korean.

The execution model uses a queue where each task spawns agents that make tool calls (WebFetch for HTTP requests, Bash for command execution) through an interception layer. Here's the critical architectural decision: asset allow/block rules gate database writes, not network calls. When an agent fetches https://out-of-scope.example.com, the HTTP request succeeds—the rule only prevents inserting that asset into insert_assets or creating follow-up tasks via add_intent. This is documented but counterintuitive for security practitioners expecting a sandbox.

// Pseudocode representation of the asset filter pattern
func (a *Agent) HandleToolCall(call ToolCall) error {
    result := call.Execute() // Network call happens here
    
    if call.Type == "WebFetch" {
        asset := parseAsset(result.URL)
        
        // Scope check only happens at DB write time
        if !a.assetFilter.IsAllowed(asset) {
            a.logger.Debug("Asset blocked by scope rules")
            return nil // Silently skip recording, don't fail the call
        }
        
        return a.db.InsertAsset(asset, result.Body)
    }
    return nil
}

The supervisor pattern (start.sh/start.bat) enables in-app updates by interpreting exit codes: code 99 triggers a binary swap and relaunch, while other codes terminate cleanly. This is elegant for zero-downtime patching but creates an operational gotcha—running ./scopeweaver directly bypasses the supervisor, so in-app updates silently fail without error messages. Production deployments must use the wrapper scripts.

LLM provider abstraction supports Anthropic, OpenAI, GLM, and Ollama with a "local-only" mode that's more sophisticated than typical air-gap implementations. Enabling allowLocalModels blocks cloud providers and disables web search and update checks, but crucially still permits outbound connections to pentest targets. This matches the threat model: you don't want reconnaissance data leaking to OpenAI, but you need agents to probe the target network.

# docker-compose.yml snippet for air-gapped Ollama deployment
services:
  ollama:
    image: ollama/ollama:latest
    networks:
      - pentest-internal
  scopeweaver:
    environment:
      - ALLOW_LOCAL_MODELS=true
      - OLLAMA_BASE_URL=http://ollama:11434
    networks:
      - pentest-internal  # Agent network
      - target-network     # Target access
    # No internet access—cloud LLMs blocked at container level

The ScopeSentry integration deserves attention: it's not just an import feature but an asset graph synchronization mechanism. When ScopeSentry discovers subdomains via passive DNS, ScopeWeaver can ingest them as exploration starting points, letting agents build on existing reconnaissance instead of duplicating work. This bidirectional flow (ScopeSentry finds assets → ScopeWeaver probes them → findings update ScopeSentry) creates a feedback loop missing from standalone tools.

Skill guidance templates control agent behavior through prompt engineering, with fallback to role defaults when rendering fails. The catch: template errors only appear in backend logs, leaving the frontend silent while agents run with degraded prompts. A malformed Jinja template in your custom "subdomain enumeration" skill won't throw a UI error—you'll just notice agents behaving oddly and have to grep logs for render failures.

Multi-language support extends beyond UI strings to agent reasoning. When you create a task with language: ko, the agent's internal guidance prompts render in Korean, affecting how it describes findings and structures reports. User edits persist in their original language, but agent-generated content follows the task language. This matters for compliance workflows where stakeholders require native-language reports without manual translation.

Gotcha

The "scope is a filter, not a firewall" architecture will bite you if you're not prepared. Asset allow/block rules control which findings get recorded, but agents can still make arbitrary HTTP requests and shell calls to out-of-scope targets. You need external egress controls (firewall rules, HTTP proxy with allowlisting) to enforce network boundaries. The documentation mentions this, but the UI design—with prominent allow/block rule configuration—gives false confidence that you've sandboxed execution. In practice, you're just organizing findings, and a misconfigured agent could still port-scan your production database or exfiltrate data to an attacker-controlled domain.

Windows deployment is painful compared to Linux. The start.bat wrapper expects PostgreSQL running on localhost:5432 and retries connection failures in a loop, but errors are generic. If your database is on a different port or lacks proper credentials, you'll see "Connecting..." messages until you Ctrl+C and manually debug. Linux users get Docker Compose templates with health checks and automatic database initialization; Windows users get a batch file and a prayer. The single-server constraint compounds this—you can't run multiple ScopeWeaver instances against the same PostgreSQL database for horizontal scaling, creating a single point of failure for large engagements. If your use case involves parallel testing of multiple scopes, you're forced into separate databases and manual finding consolidation.

Verdict

Use if: You operate ScopeSentry and need autonomous reconnaissance with asset correlation, require Korean or multilingual reporting for compliance/stakeholders, run sensitive engagements where Ollama local inference justifies operational complexity, or value persistent task queues that survive restarts without losing agent state. The supervisor-based update mechanism and language-aware agent prompts are genuinely useful for long-running red team operations. Skip if: You expect network isolation without external firewall setup (scope rules won't save you), need horizontal scaling across multiple servers (single-instance limit is hard), run on Windows without database admin skills (manual PostgreSQL setup is miserable), or require guaranteed support for OpenCode/GLM integrations (templates exist but lack official backing). Choose Metasploit for mature exploit delivery with real pivoting, Nuclei for pure vulnerability scanning speed, or PentestGPT for human-in-loop LLM assistance. ScopeWeaver's niche is the practitioner who trusts ARTEX's architecture, needs multilingual output, and understands they're adopting a rebranded fork with unclear upstream sync strategy.