What it actually costs to self-host an agentic pentester

“It's open source, so it's free” holds right up until the agent makes its first API call. The Xalgorix engine is Apache-2.0 and always will be — but an autonomous pentester is, under the hood, a very determined LLM user. When you self-host, every token it spends lands on your provider bill. Here's an honest look at what that adds up to.

What's genuinely free

The engine itself. Clone it, build it, run it forever — no license fee, no seat count, no phone-home. Point it at a local model through Ollama and you can run the whole thing with no API bill at all: you trade tokens for GPU time and slower, more hand-held scans. That path is real and supported.

The part that isn't free: tokens

A scan is not one prompt. The agent works a 22-phase methodology, calls tools, reads their output, reasons about the next move, retries when something fails, drives a browser, and carries a growing context of everything it has seen — then an independent verifier re-exploits each candidate finding. Every one of those steps is tokens in and tokens out. Depth and scope are the multipliers, and they swing wildly from target to target.

A back-of-the-envelope estimate

Tokens per scan are genuinely variable — a light single-target run might sit in the low-single-digit millions; a deep wildcard scan across a real attack surface can run past 10M. Rather than quote a number as gospel, here's the shape of the math with illustrative inputs:

Illustrative only — use your own model + scope:

  20 scans / mo
   x 5M tokens / scan     (deep, multi-phase, with verification)
   x $6 / 1M tokens       (blended input+output, frontier model)
  -----------------------
  ~ $600 / mo in LLM tokens alone

  (before your servers, OOB infra, and the hours to run it)

Change any input and the total swings hard: a cheaper model or a lighter scope drops it, a deeper scan or a pricier model raises it. That's the whole problem — the bill is a moving target you only see after the run. You can plug your own numbers into the cost calculator and watch it move.

The costs that never show on the token bill

• Infrastructure — a box big enough to run the browser, the toolchain, and concurrent scans, kept patched and online.
• Out-of-band infra — whole vuln classes (SSRF, blind RCE, XXE, blind SQLi) need a public collaborator server to catch callbacks. Standing one up and keeping it reachable is on you.
• Rate-limit babysitting — providers throttle; long autonomous runs hit ceilings, back off, and stall unless someone is tuning them.
• Your time — installs, upgrades, key rotation, and the occasional wedged scan. Usually the most expensive line of all.

When self-hosting is the right call

Plenty of the time, honestly. If data must never leave your network, if you need to run fully offline or air-gapped, or if you already operate the infra and have cheap or local tokens at volume, self-hosting wins — and that's exactly what the open-source build is for. We'd rather you run it than run nothing.

The hosted trade: pay for outcomes, not tokens

The hosted cloud runs the same exploit-verified engine but flips the cost model. You don't bring an API key and you never see a token bill — you pay 1 credit per live host scanned. A single-target scan is one credit; a wildcard scan bills one credit per subdomain that actually responds, and only if it responds. It's outcome-based and predictable, and the OOB infra, scheduling, scaling, and updates are handled for you.

Not sure which side you land on? The side-by-side calculator does the math both ways, and pricing starts at a single $1 scan with no subscription. Run whichever fits — just go in knowing what each one costs.