Vigolium Breakdown: 324 Native Go Scan Modules Underneath, an AI Swarm That Writes Its Own Attack Plugins on Top

1. At a Glance: Is It Worth Your Time

Rating: ★★★☆☆ (3.5 / 5)

Why it is worth a look first: among this batch of tools, it is the only one where both layers — “solid traditional scanner foundation + AI layer on top” — are actually built out. Many AI security tools start from an agent built from scratch with a thin capability layer underneath; Vigolium does the reverse — it first wrote a complete DAST engine in Go (324 modules, OAST out-of-band detection, value-aware parameter mutation, multi-stage pipeline, multi-session authentication), and then bolted AI on top. That gives the AI layer something real to drive, instead of just something to chat about.

A few technical points I think are done well:

• Value-aware mutation: instead of blindly stuffing payloads, it first classifies parameters by semantic type (integer / UUID / JWT / email), then mutates according to intent. This directly raises the hit rate.
• Automated OAST correlation: blind XSS / SSRF / command injection go through interactsh callbacks, with payloads correlated automatically.
• Swarm mode writes its own JS attack extensions: master agent analyzes the input → selects modules → generates custom JS attack extensions → runs code audit and SAST → executes the scan → triages findings. This closed loop is rare in open source.
• The agent runtime is a self-built Go package, pkg/olium, running in-process — no subprocess SDK pool.

But the score is held down to 3.5 because several things are hard blockers: agent mode explicitly has no sandbox (the LLM has full shell / file / network access on the host — the project says so itself); extensions can run arbitrary commands; the license status is inconsistent (README says MIT, GitHub API detects NOASSERTION); and the author is @j3ssie with a project only 7 months old, so maturity still needs time to prove out.

Key Data (as of 2026-10-02)

Who It’s For

Building on It

2. What It Is, What It Isn’t

• Not a pure AI agent. Its base is a complete Go DAST engine; the AI is optional (Agentic Scan).
• Not a Nuclei replacement. Nuclei is template-driven PoC matching; Vigolium has active fuzzing and a mutation engine.
• Not SAST. It has agent audit for source-code auditing, but that is an add-on capability of the agentic layer — its main business is DAST.
• Not a cloud SaaS (the open-source part, that is). The Cloud Console is a separate paid upgrade.

Three keywords: dual-engine (native + agentic), value-aware mutation, in-process agent runtime.

3. Native Scan: 324 Modules as the Foundation

This is where its value sits.

Pipeline Layers

The soft-404 detection deserves its own mention — the biggest noise source in directory brute-forcing is applications that “return 200 for everything”, and fingerprint-based soft-404 detection cuts false positives significantly.

Getting-Started Commands

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# single target (default balanced strategy)
vigolium scan -t https://example.com

# pick a strategy preset
vigolium scan -t https://example.com --strategy deep

# run only selected modules
vigolium scan -t https://example.com -m xss-reflected,sqli-error

# scan from an OpenAPI spec
vigolium scan -T openapi.yaml -I openapi

# pipe URLs from stdin
cat urls.txt | vigolium scan

# run a single stage
vigolium run discovery -t https://example.com

# produce an HTML report
vigolium scan -t https://example.com --only discovery --format html -o report.html

Authenticated Scanning (the Key to IDOR/BOLA)

1
2
3
4
5
6
7
8
9
10
11
12
13

# inline multi-session (name:Header:value)
vigolium scan -t https://example.com \
  --auth "admin:Cookie:session_id=abc123" \
  --auth "user:Cookie:session_id=xyz789"

# load sessions from a file
vigolium scan -t https://example.com --auth-file ./admin-session.yaml

# with an automated login flow + token extraction
vigolium scan -t https://example.com --auth-file ./login-flow.yaml

# custom header
vigolium scan -t https://example.com -H "Authorization: Bearer token123"

Multiple sessions are the prerequisite for IDOR/BOLA and broken-access-control checks — you request the same resource with two sessions of different privilege levels to tell whether an escalation exists. This capability is missing from many scanners.

Note: --auth / --auth-file used to be called --session / --session-file; the old names still work as deprecated aliases.

4. Agentic Scan: Two Modes, One Self-Built Runtime

All agent modes run on the native Go pkg/olium engine: a turn-based loop, a built-in tool registry, skills support, pluggable provider drivers — no subprocess SDK pool. That choice gives it better performance and controllability than “shelling out to an external CLI”.

Autopilot vs Swarm

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# Autopilot
vigolium agent autopilot -t https://example.com
vigolium agent autopilot -t https://example.com --source ./src --prompt "focus on auth bypass"
vigolium agent autopilot -t https://example.com --diff main...feature/auth   # diff only
vigolium agent autopilot -t https://example.com --intensity deep

# Swarm
vigolium agent swarm -t https://example.com/api/users --vuln-type sqli
vigolium agent swarm -t https://example.com --discover                       # full scope
vigolium agent swarm --input "curl -X POST https://example.com/api/login -d '{\"user\":\"admin\"}'"

# source-code audit
vigolium agent audit --source ./src                                  # default auto
vigolium agent audit --source ./src --driver audit --mode deep       # vigolium-audit only
vigolium agent audit --source ./src --driver piolium --mode balanced # piolium only
vigolium agent audit --source ./src --driver both                    # both, in sequence
vigolium agent audit --source ./src -S --output-dir ./audit-out      # one-shot DB + HTML report

# use olium directly (TUI or headless)
vigolium ol                        # start the TUI
vigolium ol --prompt "..."         # one-shot (-p implies headless)

The fact that Swarm generates custom JS attack extensions is its most distinctive trait — instead of picking from a fixed module library, it has the agent write attack code on the spot for the current target. That is both the highlight and the risk (see Section 7).

Provider Support (10)

openai-compatible (default), openai-codex-oauth, openai-api-key, openai-responses, anthropic-api-key, anthropic-oauth, anthropic-cli, anthropic-compatible, anthropic-vertex, google-vertex.

The same modes are exposed over the REST API, with SSE streaming and an OpenAI-compatible chat endpoint.

5. Server Mode and Proxy Bridging

1
2
3
4
5
6
7
8

# start the API server with authentication
vigolium server -k my-secret-key

# open a transparent HTTP proxy to record traffic
vigolium server -k my-key --ingest-proxy-port 9003

# auto-scan traffic as it arrives
vigolium server -k my-key --scan-on-receive

1
2
3

# feed traffic into a running server
cat urls.txt | vigolium ingest -s http://localhost:9002
vigolium ingest -s http://localhost:9002 -i api.yaml -I openapi

Proxy integration: there are official burp-vigolium (Burp Suite extension) and caido-vigolium (Caido plugin) projects; both use the same bridge protocol (-B/--burp-bridge-url, alias --caido-bridge-url), and ingested traffic is tagged with the source proxy.

This one is very practical in the field: browse the application manually once, then feed the Burp traffic straight into Vigolium to scan — far more efficient than assembling URL lists by hand.

6. Benchmarks

The project states it continuously benchmarks against deliberately vulnerable applications, and stress-tests on real targets via bug bounties and responsible disclosure:

• Self-hosted (Docker): DVWA, OWASP Juice Shop, VAmPI, crAPI, Vulnerable Java App, Vulnerable Nginx, OopsSec Store (a custom Next.js app)
• External (hosted): Acunetix TestPHP, Gin & Juice Shop, Testfire
• XSS & multi-vuln: BruteLogic XSS, XBOW (XSS, SQLi, SSTI, LFI, SSRF, XXE, command injection)

How to run: make test-canary (Docker apps) or make test-integration (XSS).

But note: the README lists the target ranges, without giving quantified detection / false-positive rates. To assess effectiveness you have to run make test-canary yourself. Compared with Dark-Moon’s explicit “57 vulnerabilities” figure, this is a notch less transparent.

7. Boundaries and Risks (the part that must be said honestly)

1) Agent mode has no sandbox — this is the heaviest item. Verbatim from the official SECURITY section:

Vigolium is an offensive security tool, and two parts of it are intentionally permissive: agent mode runs with no sandbox (the LLM has full shell, file, and network access on the host) and extensions can run arbitrary commands. Run agent mode in a disposable container/VM scoped to the engagement, and treat untrusted extensions like untrusted code.

In plain terms: when agent mode runs, the LLM has full shell, file, and network access on your host. The project itself offers mitigations — use a disposable container / VM, and treat untrusted extensions like untrusted code. Please actually follow that advice; do not run agent mode on your development machine or any machine holding production credentials.

For comparison: LuaN1ao runs one Docker sandbox per task with a Gateway as the sole egress; Dark-Moon never lets the AI execute commands directly — everything goes through MCP. On this axis Vigolium is clearly behind, and it admits so itself.

2) Extensions can run arbitrary commands. Same story — JS extensions are not sandboxed. Installing a third-party extension = installing arbitrary code execution.

3) The license status is inconsistent. The README says MIT License, but the GitHub API classifies the repo as NOASSERTION. This kind of mismatch usually means the LICENSE file contains non-standard clauses, or detection failed. Before enterprise use, have a human read the LICENSE file itself — do not rely on the README or the API field alone.

4) The Cloud Console is the paid upgrade; the README calls it the “upgraded, fully-featured version”. That implies the open-source edition may hold features back. How much is not stated — verify for yourself during evaluation.

5) The project is only 7 months old with 118 commits. For an engine of 324 modules, that volume means many modules may not be battle-tested. The 4 open issues more likely reflect a still-small community than an absence of problems.

6) The benchmark has no quantified numbers. See Section 6 — there is a target list, but no detection-rate data.

7) The platform/ directory is not part of the core scanner. The README says it holds the external toolchain and the UI Dashboard, and that “No changes should be made to it”. Do not let it distract you when reading the code.

8. Getting Started (in This Order)

1. Start with Native Scan; do not jump straight to agents. vigolium scan -t <target> --strategy deep is the zero-risk entry point, and it lets you fully absorb what the 324 modules are worth first.
2. The Docker install is the least effort — and it isolates you as a bonus. Do not install the binary directly on your dev machine.
3. Set up --auth-file for your first run. Multi-session authentication is the prerequisite for its IDOR/BOLA work; without sessions you give up that capability entirely. Ready-made examples live under public/presets/sessions/.
4. Hook up the Burp / Caido bridge. Browse the app manually and then feed the traffic in — far more efficient than URL lists, and a real field advantage over comparable tools.
5. If you want agent mode, prepare a disposable VM first. To repeat: agent mode has no sandbox; the LLM has full host privileges. Use a disposable container / VM and throw it away afterwards.
6. Do not install third-party JS extensions of unknown provenance. Extensions can run arbitrary commands — that is equivalent to installing arbitrary code.
7. Want to verify effectiveness? Run the benchmark yourself: make test-canary. Trust no claim without numbers, including the official ones.
8. For enterprise use, have a human read the LICENSE first (the README’s MIT and the API’s NOASSERTION do not match).

9. The One-Line Verdict

If what you want is a Go DAST with solid modules, rich input sources, and Burp integration, Vigolium’s Native Scan is worth a try; but touch the Agentic Scan layer only inside a disposable VM — it is the project I have seen recently whose own docs state “no sandbox + full host privileges” most bluntly.

First move for red teamers: spin it up in Docker → vigolium scan -t <your range> --strategy deep → configure --auth-file with two sessions and run the IDOR checks → hook up the Burp bridge and feed in real traffic. After those four steps you will know exactly what its 324 modules are worth to you. Leave agent mode alone for now.