Skip to main content
Gimorra arms your model with agents, attack skills, validators and an evidence trail, then pushes it to its ceiling: planning the attack, chaining bugs, re-proving every finding and writing the report. Point it at a target and walk away.
An illustrative gimorra scan in six scenes: the scope guard strikes out a denied host, recon passes union onto one attack-surface table, a master agent dispatches four specialist children, probers hunt four asserted premises and refute two, the proof engine re-proves eleven proposed PoCs and keeps three, and the run comes back as one folder of reproduced findings.

One run from start to finish. A brief becomes a plan, recon maps the target, the agents propose candidates, and the proof engine drops every candidate it cannot prove.

Click through a finished run in the demo console. It is read-only and needs no login. Want Gimorra on your own target? Email [email protected], request a demo, or visit gimorra.vigolium.com. Already invited? Jump to Installation.

Features

  • Every ounce out of your model. A supervisor splits the work across specialist agents armed with attack skills. A second model reviews the plan and calls out what it missed.
  • Any starting point. A URL, an IP range, a domain, a repo, an app bundle, an API spec or a whole bug-bounty scope document. One command takes all of them.
  • Brief it in plain English. -p "focus on IDOR and broken access control" and the run aims there. --dry-run shows which words set which flag.
  • Re-proved, not guessed. Deterministic code with no AI in it re-tests every candidate. An agent can never mark its own finding confirmed.
  • Chains bugs, chases impact. Gimorra combines findings into larger attacks, then follows a confirmed bug to see what else it hands an attacker.
  • Hunts what scanners miss. The hypothesis phase assumes a critical bug exists and goes looking for it, long after an ordinary pass would give up.
  • Logged in like a real user. Hand it accounts and it logs in as each one before the attack. Access-control bugs between users are fair game.
  • Source and live, together. Pass --source and the run audits the code while it attacks the app. Every agent can read the source.
  • Evidence you can replay. A hash-chained trail ties each finding to the exact request and response that proved it, with copy-paste curl steps.
  • Memory between runs. The next engagement starts from what the last one learned: pages, endpoints, working techniques and held accounts.
  • Bring your own model. A Claude login, an Anthropic key, a proxy or any OpenAI-compatible endpoint. Route the supervisor and the children to different models.
  • Built for CI and long runs. --exit-on-findings fails the build. --detach survives a closed terminal. --resume picks up where a run stopped, without paying twice.

Inside the console

Everything a run does lands in the console, live while it runs and frozen when it finishes. These screenshots come straight from the demo console.
Gimorra console dashboard showing 6 engagements, 39 findings, 25 proven, 234 mapped assets, spend, a findings-over-time chart by severity and the proof-engine verdict breakdown

The Gimorra console. Every engagement, every finding, every dollar spent, on one screen.

Engagement report for soylent-source showing 11 findings, 7 jobs, 43 attack-surface assets, 11 hash-chained proofs, spend, severity bars and verdict breakdown

Engagement report: proven versus recorded, by severity and by class

A confirmed critical SQL injection finding with CVSS vector, triage state, a differential true-versus-false proof verdict and two copyable curl reproduction steps

Finding detail: the proof verdict and the requests that reproduce it

Jobs table listing agent and recon jobs with goals, status, commands run, cost, tokens and turns, with the sub-agents each job spawned

Agent jobs: the supervisor, its specialists, and what each one cost

Attack surface table of hosts, services and endpoints with who found each one and whether it is in scope

Attack surface: every host, service, endpoint and parameter, scope-checked

Coverage matrix of techniques run per asset, with skipped work, out-of-scope items and the leads the run could not finish

Coverage: which technique ran where, and what the run never answered

Engagements list with target, status, lifecycle, current phase, findings, jobs and surface counts for six engagements

Engagements: every run, its phase, findings and surface at a glance

What a run does

One command runs a whole engagement through a fixed order of phases. The console prints one line per phase, marked with its symbol.
1

⌥ Resolve, ◎ target and ◈ scope

Your plain-English brief becomes flags, and Gimorra shows which words produced each one. It authorizes the target and locks the scope. From here on, the scope guard checks every tool call against it.
2

⊙ Crawl

Vigolium crawls the target and runs a DAST pass at native speed, no model involved. It hands the agents leads, not findings.
3

⌖ Observe

The agent takes a short, passive first look: what the target is, what it runs, and what deserves a closer look.
4

⋆ Ideate

The agent ranks what is most likely broken on this target, with a reason for each. No requests, no findings, just a plan of attack.
5

❖ Attack

A supervisor splits the work across specialist child agents, one lead each. A cheaper model reviews the plan and flags what it misses. The scope guard checks every call.
6

⊢ Proof

Deterministic code, with no AI in it, re-tests every candidate. Only what this proof engine confirms becomes a finding.
7

Closing phases

The run keeps digging after the first proof pass:
  • ⊔ Salvage recovers results from child agents that stopped before they wrote them.
  • ≟ Hypothesis assumes a high or critical bug exists and hunts for it.
  • ⊨ Triage settles what the proof engine left open: repair the candidate or mark it a false positive.
  • ⋈ Compose chains findings into a larger attack.
  • ⊩ Exploit follows one confirmed finding to see what else it gives an attacker.
Everything these phases produce goes back through the proof engine.
8

✎ Elaborate, ⊕ surface and ≡ done

Gimorra writes the analyst notes, lists every page and endpoint it found, and saves the run in one folder: findings, evidence trail, agent transcripts and the report.
Some phases switch on when you give the run their input: Turn off a default phase with --skip <phase>, for example --skip hypothesis. Running a scan covers the rest of the flags.

Safety controls in code

Gimorra doesn’t ask you to click “approve” on every action. Its guardrails live in code, so you set the level of supervision once per run and let it work.

The proof engine decides

Agents propose, deterministic code disposes. Each candidate is re-tested with the least invasive request that settles the question.

Cleanup and a kill switch

A run undoes the changes it makes to the target. One command ends the engagement: no agent picks up queued work, and the proof engine accepts nothing more.

Scope guard on every tool call

Every tool call that touches the target is checked against the scope before it runs. A deny rule beats any allow rule.
None of the three depends on the model, the agent or the network stack. A prompt injection that hijacks the model can’t switch them off.
Gimorra works only against targets you are authorized to test. Without an authorization record, the code refuses to start any active testing.

What you can give it

--intensity sets how hard the run hits, from passive to aggressive. Nothing else needs tuning to get a first result.

Vigolium or Gimorra

Vigolium · Free and open source

The best DAST CLI on the market.Free, open source, and fast enough to gate every build. Native scans for breadth, agentic scans for depth, and every finding ships with the request that proves it.
  • 215+ scanner modules in one binary
  • Native speed on every push, agentic depth before every release
  • Runs on your own infrastructure, in your own CI

Gimorra · Proprietary, by request

Gimorra unlocks the full power.Vigolium is the engine. Gimorra is the whole red team. It arms your model with agents, attack skills, validators and an evidence trail, then pushes it to its ceiling: planning the attack, chaining bugs, re-proving every finding and writing the report. Point it at a target and walk away.
  • Squeezes every ounce of intelligence out of the model you bring
  • Any starting point: URL, IP range, repo or app bundle
  • Every candidate re-proved before it counts as confirmed
Gimorra runs its tools on the machine where you start it, so anything a tool does happens on that machine. Run it in a container. An all-in-one image is available for this.

Next steps

Installation

Get your invite, install the CLI and the Vigolium engine, and check the host.

LLM configuration

Plug in the model that drives the agents: a Claude login, an API key or your own endpoint.

Running a scan

Targets, briefs, intensity, budgets, scope and where the results land.

See what Gimorra finds before you commit: open the demo console, then email [email protected] to put it on your own target.