Vigolium: a Go vulnerability scanner with an agent mode bolted to the same engine

Two modes that share one binary

Vigolium splits scanning into two modes and the split is real rather than branding. Native scan is the deterministic one: `vigolium scan` runs a multi-phase pipeline across 324 modules, 207 active for fuzzing and 117 passive for pattern matching. Agentic scan is `vigolium agent`, where a language model plans attacks, picks modules, writes custom extensions and triages findings.

The interesting part is that these are not two programs. The README states that every agent mode runs on an in-process runtime in `pkg/olium`, described as a turn-based loop with a built-in tool registry, skills support and pluggable provider drivers, and it contrasts this explicitly with subprocess SDK pools. So the agent's decisions reach the same scanner the flag-driven path uses, in the same process, with the same database.

That has a practical consequence for anyone automating this. If an agent and a script both write findings, they write them through one schema and one store. The README lists source-audit drivers, `audit`, `piolium` and a unified `audit` dispatcher, that share a single finding schema and database tagging, and the same modes are exposed over a REST API with SSE streaming and an OpenAI-compatible chat endpoint.

Installing it across shell, npm and Docker

There are three install paths and the README marks the shell installer as recommended.

curl -fsSL https://vigolium.com/install.sh | bash

The npm route installs the same tool as a package, which is the path to use on Windows, or you can download `vigolium_<version>_windows_amd64.zip` from the releases page and put `vigolium.exe` on your PATH.

npm install -g @vigolium/vigolium

Docker is there too, and the image is published under a personal namespace rather than the project's own.

docker pull j3ssie/vigolium:latest

The Windows caveats are the sort of thing that saves an afternoon. Windows ships as x64 only and runs under emulation on ARM. The shell installer is POSIX-only, which means `vigolium update` does not exist on Windows, so upgrading means re-running the npm install or fetching a newer zip by hand.

Building from source wants Go 1.27 or newer and bun 1.3.11 or newer, which tells you something about the toolchain: this is a Go program with a JavaScript component embedded in it, and that JS is not incidental, since it is the extension mechanism.

OAST, value-aware mutation, and a browser in the pipeline

Four capabilities distinguish Vigolium from a template runner, and they are worth taking one at a time.

Out-of-band testing uses interactsh callbacks with automatic payload correlation, which is how you find blind XSS, blind SSRF and blind command injection. A payload that produces no visible response still produces an outbound request, and correlating the callback back to the payload is what turns that from a guess into a finding. The dependency list confirms the project leans on ProjectDiscovery libraries here, including interactsh, nuclei, rawhttp and ratelimit.

Value-aware mutation classifies parameters by semantic type, naming integer, UUID, JWT and email as examples, then mutates according to intent. Sending a UUID-shaped value to an integer parameter and having the scanner notice is a small idea with real value, because type confusion is exactly where naive fuzzers produce noise.

Content discovery is handled by named components in the pipeline: Deparos for discovery and Spitolas for browser and SPA spidering. A real browser in the path is expensive, which is why it is a phase rather than the default behaviour. It is also the only way to reach routes that exist only behind client-side rendering, and those routes are increasingly where the bugs are.

Custom JavaScript modules and hooks run in an embedded JS engine with session-aware HTTP APIs, so you can write a module that carries session state without re-implementing the transport.

Starting a scan and holding its budget

The quick start is deliberately small. A single target uses the default balanced strategy, a preset changes the depth, and `-m` restricts the run to named modules, which is the flag to reach for when you do not yet know what you want to hear.

vigolium scan -t https://example.com

vigolium scan -t https://example.com -m xss-reflected,sqli-error

Input is flexible in a way that suits existing workflows: URLs, OpenAPI and Swagger specs, Postman collections, Burp Suite exports, cURL commands and Nuclei JSONL. Authentication supports inline sessions, session files or full auth configs with login flows, token extraction and IDOR and BOLA testing, so the authenticated parts of an application are reachable rather than skipped.

Scale handling is described as a concurrent worker pool with per-host rate limiting and a hybrid in-memory, disk or Redis queue, with self-contained HTML reports. The Redis option is the interesting one, because it turns a single-machine scan into something several machines can share, which matters for a large target list.

Agentic mode adds its own flags: full scope with `--discover`, and change-focused runs with `--diff` and `--last-commits`, which is the version you would put in CI.

Recent releases are fixing quietly serious scan bugs

The three most recent releases are all version 0.4.x, published within a week of each other in September 2026, and they are unusually candid about defects. That candour is itself a signal about the project's maturity.

v0.4.8 fixed a schemeless target silently skipping spidering. Passing `-t example.com` without a scheme scanned fine under probing and discovery but the crawler seed was rejected, so a run with `--only spidering --soft-fail` exited successfully having recorded nothing. It also fixed the startup banner advertising the wrong time budget, so `--spider-max-time 5m` printed 6 minutes while the phase actually ran for five, and it made `--db-isolate` warn instead of aborting when combined with the stateless flag.

v0.4.7 was a read-surface correctness release. The worst entry there: LIKE metacharacters in a search term were interpreted rather than matched, so searching for a literal percent sign returned every record. The same release fixed `--header` and `--body` scanning the whole stored message instead of their own region, and fixed a read command pointed at a missing database creating that database and reporting zero results with exit code 0.

That last bug deserves emphasis for anyone scripting this. A tool that silently creates an empty database and reports success is the kind of failure that produces a clean-looking report and a missed vulnerability.

Licensing and the parts the README leaves out

The licence needs a sentence of care. The repository's licence field is left unset, while the v0.4.8 release notes say the project was relicensed under MIT and that `LICENSE`, `THIRD_PARTY_NOTICES.md`, the npm package metadata and the server's licence header were all updated to match. Both facts sit in the same repository. Read `LICENSE` directly, and note that a `THIRD_PARTY_NOTICES.md` at this scale means there is bundled third-party code whose terms you inherit.

The README also stops short of everything the project contains, so some things are only visible in the file tree. There is `AGENTS.md` and `CLAUDE.md`, which suggests the agent modes have their own contributor instructions. `SECURITY.md` is the disclosure policy, and `HACKING.md` holds build and run details. The Makefile's target list is a good map of what the project can actually run: benchmarks against CRAPI, Juice Shop, DVWA, VAmPI and vulnerable Java and nginx images, plus an entire family of xbow targets, each with its own test target for SSTI, XSS, SQLi, LFI, command injection, SSRF and XXE.

That target list is the most honest measure of how seriously this is being developed. A project that keeps per-classification test suites against known-vulnerable applications is a project that expects its scanner to be contradicted by other tools. Commercial and hosted options exist through vigolium.com and docs.vigolium.com, and the sandbox infrastructure is sponsored by Daytona.

Editorial conclusion

Vigolium is most interesting for the part most scanner projects cannot claim: both modes run in one binary on one Go runtime, so an agent can select native modules, write a JavaScript extension mid-scan, and triage the result without leaving the process. That also means the same rule engine is doing the deciding, whether the caller is a flag or a language model, which is the design you want from this category. The cost is size and a fast-moving surface, with recent releases chasing real bugs like schemeless targets silently skipping spidering and search filters interpreting SQL wildcards. Verify two things before trusting it with a target you care about: whether the licence in the repository LICENSE file is the MIT the latest release describes, since the metadata field is unset, and whether the module registry numbers match the release you actually install. Start with a narrow `-m` module list against a target you own.

Frequently asked questions

Official sources

1. Issues
2. Project website
3. README
4. Releases
5. vigolium/vigolium on GitHub