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
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.