Suijin

Your team of fully autonomous web app pentesters and red teamers for any situation.

You tell it what to test. It maps the product landscape, spawns the right specialists for each vulnerability class, discusses attack surfaces with the other sessions, shares confirmed findings with the team automatically, and gets hacking. It runs the engagement — recon, exploitation, post-exploitation, report — like a pentester who never gets tired, never skips the boring surfaces, never tunnels-visions on one endpoint while 90% of the target sits untested, and proves every finding by running the exploit before claiming it, all while you supervise from an Operator Console watching over what everyone on the team is doing.

Who it's for

• Bug bounty hunters who can load the program rules, point Suijin at in-scope targets, and get back verified findings — not "the model thinks there's an IDOR here," here's the POC, the output, the marker.
• Pentest teams running authorized engagements. One agent per target, or a whole team on one target — they split lanes, share dead ends, and never re-burn a payload a peer already ruled out.
• CTF players. Flip the profile and the doctrine changes: the flag is the objective, a confirmed bug is a stepping stone, persistence prioritised over tidiness.
• Security researchers who want an agent platform that grades itself — onboard labs with chain-verification tests and bench scoring, so "did my change make the agent better" is a number, not a vibe.

What a run looks like

1. Start it.

suijin lab up

suijin
(mode: type 1)
target: 127.0.0.1:6000

It maps the surface, probes, exploits, escalates to as far as it can go, and writes the report — narrating its reasoning in your terminal the whole way. You can interrupt at any point to redirect it; it can pause between turns, resume saved runs, and pick up an engagement weeks later from its .sje snapshot.

2. Or start a team. Open one terminal per agent. Sessions on the same target find each other, introduce their lanes, and coordinate — while agents on different targets are kept strictly apart.

3. Watch from one screen.

suijin operator

Every running agent on one dashboard: live cards, iteration history, confirmed exploits, the team's chat. Keyboard-first — tab cycles panels, j/k pages the roster, ←→ walks any agent's iteration history. The input box is a command line:

4. Trust the output. A finding only counts when its POC ran and the target produced the expected marker — unique, target-derived strings; 200 OK proves nothing. No match means the exploit comes back with every command and output attached so you can fix or drop it. A finding without a cataloged POC is a rumor. Confirmed findings capture their verifying output as tamper-evident, content-addressed evidence — the report re-hashes every proof at generation time and flags drift, so what you submit is provably what you verified. And severity is honest by construction: the system caps claims whose evidence only shows information-class output.

4a. The system catches what the model misses. Every HTTP request feeds an observation engine that deterministically detects IDOR and access control gaps from accumulated evidence — different credentials getting different responses for the same object surfaces as a finding the model can't ignore. When a vulnerability class is detected, sub-agents get the specialist's doctrine: the IDOR expert tests cross-account systematically, the injection expert knows the filter evasion playbook. And when the agent tunnels on one endpoint, the breadth alert tells it to rotate: "68% of your last actions target Search & Redirectors. 5 product families untested. Pick one."

5. Come back tomorrow. Suijin remembers: blocked patterns, WAF rules, false positives, dead batteries, what worked where. The next engagement — same target or same tech — starts with all of it and skips the graveyard. Resumed runs scrub verified-dead credentials from carried state — a key that was SERVICE_DISABLED yesterday doesn't come back as today's "discovery."

6. Or run it in a box.

suijin box

A sealed linux environment (OrbStack on macOS, or Docker) that runs Suijin and its tools with your device untouched: build it once, enter it, work inside. Your config, packs and prompts sync one-way in — nothing the box generates ever flows back — and entering detects drift, offering to sync and install any newly-listed tools. Engagements live on the box's own disk and survive restarts; destroying it archives everything out first and asks you to type the confirmation. Bare suijin keeps working exactly as before — the box is a choice, not a migration.

Comparison

Safety first

New to it — or new to the agent? Run it against the onboard lab: a multi-service target (15 named services behind a gateway/auth/core plane, ~100+ vulnerability instances, cross-service chains, decoys, 22 flags) that runs on your machine. Sharpen against something that can't get you arrested.

suijin lab up
suijin
press 1
press 1
target: 127.0.0.1:6000

Quick start

# one command (macOS / Linux)
curl -fsSL https://raw.githubusercontent.com/0xwi11iam/Suijin/main/install.sh | bash

# first engagement
suijin engage "http://127.0.0.1:6000 — full assessment"

# watch every agent from one screen
suijin operator

# pipx / uv (installable package)
pipx install suijin

# with the Neo4j knowledge-graph backend (json is the default)
pipx install "suijin[kg]"

# manual
git clone https://github.com/0xwi11iam/Suijin
cd Suijin && pip install -e .

# dev install (live local copy)
pip install -e ".[dev]"

# docker (turnkey)
docker build -t suijin .

_{Authorized security testing only.
On a more serious note, never point Suijin at a system you do not own or lack written permission to test. Unauthorized access is illegal — you accept full responsibility for what you run.}

_{Licensed under AGPL v3.0 · Suijin · By 0xwi11iam(William Jiang)}