grounded plan · live execution

The AI hacks. You set how far.

An AI pentest cockpit that plans the attack and runs it live — from approve-every-command to fully autonomous, on your leash.

Recon to Domain Admin, grounded in real technique knowledge, gated at every step.

View on GitHubWhat it does ↓All features →
CI passing3 autonomy modes2,747 KB155 tools30+ surfaces
▶ the trailer
⚡ one command

/engage — point it at a target and walk away

Invoke it once, answer a short scoping interview, and HackPit runs the entire engagement itself — recon → rank → hunt every surface → chain findings → validate → write the report. No approve-each. One stop, then it goes silent until the findings land on your desk.

$ /engage acme-corp.com --goal "bug bounty, focus IDOR + SSRF"

Scope-locked · every request audited · reports written, never auto-submitted · authorized targets only.

01 // demo
02 // how it works
01

Describe

Tell it a target — a box, a domain, a bug-bounty scope.

02

Plan

It composes an attack path, each step from a real technique.

03

Propose

The AI suggests the next command — and the reason for it.

04

Approve

You okay it. Nothing runs until you do. Every time.

05

Run & adapt

It executes in a sandbox and reasons from the result.

03 // what it does
🧭

Grounded attack paths

Describe a target → an ordered recon-to-privesc plan, built from a real knowledge base, not guesses.

🎯

Gated cockpit

The AI proposes each command; in manual mode you approve every one before it runs live.

⛁

AD → Domain Admin

Load BloodHound, see the route to Domain Admin, and walk it live over WinRM.

☁

Cloud & kill-chain

IAM privesc graphs, and one route stitched across web → cloud → on-prem.

🕸️

Full web-vuln suite

Race conditions, request smuggling, cache poisoning, a token workbench, nuclei, an intruder.

🔓

Authenticated testing

Hand it your session and every scanner probes as you — most bounty bugs live behind auth.

🛡️

Shows its work

For every action, the exact footprint a defender would see — telemetry, ATT&CK, the alert that fires.

📝

Grounded reports

OSCP / CPTS / H1 reports written from what you actually did, CVSS computed not asserted.

🗂️

Everything else

C2, tunnels, evasion, code audit, 155-tool arsenal — see the full catalogue.

04 // everything it does

Plan

the companion
  • Search your knowledge — semantic search over ~2,747 techniques, one keystroke away.
  • Compose attack paths — describe a target, get an ordered recon→privesc walkthrough, grounded in real commands.
  • Run engagements — a live checklist that remembers your steps, evidence and creds.
  • Draft reports — grounded write-ups (OSCP / CPTS / bug-bounty formats) built from what you actually did.
  • Ask the assistant — a chat that knows where you are and cites real techniques.

Execute

gated · human-approved
  • Run commands live — streamed from an isolated lab or a scope-locked real target.
  • Guided loop — the AI proposes the next command; you approve each one.
  • Second opinion — any generated command gets one honestly-labelled alternative and a which-is-better verdict, on tap. Advice only — it never auto-selects.
  • Kill-chain map — watch the attack path light up as it runs.
  • Real shells — a persistent :kali shell and a full :terminal (vim, msfconsole, evil-winrm).
  • HTTP repeater — compose, send, replay and diff web requests.
  • Web-vuln testers — single-packet race conditions, request smuggling, cache poisoning, a JWT/OAuth token workbench, a nuclei template scanner and a positional intruder — safe detect, gated confirm.
  • CVE lookup — :exploits maps a service + version to public exploits.

Go deeper

the hard stuff
  • Active Directory — load BloodHound, see the route to Domain Admin, and let the AI walk it live over WinRM — Kerberoast, DCSync, AD CS (ESC1–8) and delegation abuse.
  • Cloud attack — map a cloud account's IAM to the path to admin, and chain a web SSRF into cloud credentials via the metadata service.
  • Cross-domain kill-chain — stitch web → cloud → on-prem into one route to the objective.
  • C2 & tunnels — Sliver implants, DNS tunneling, chisel/ligolo pivoting — all behind the gates.
  • Tool arsenal — 155 tools with ready-to-run commands, target already filled in.
  • Code scan — static AppSec + AI code-audit (incl. Web3), across many languages.

You hold the leash

manual → full
  • Run it three ways — approve every command, auto-run the safe stuff, or go fully autonomous inside rules you set.
  • Autonomy is off by default — two deliberate switches before anything self-runs, and a kill-switch halts it mid-run.
  • Dangerous stays human — exploitation, the repeater and risky commands never auto-fire; anything new is treated as off-limits.
  • Full mode is leashed — it acts only inside your written Rules of Engagement and a fire budget, and every action is logged.
  • Isolated lab or scoped target — practice egress-free, or bind a real engagement to an exact scope.
  • Purple-team view — for every action, see what a defender would see (telemetry, ATT&CK, the alert that fires).

See every surface in the cockpit →

◆ Local-first

Runs entirely on your machine — no cloud, no account, nothing leaving your box. Use a fully local LLM or a frontier one. The repo ships code only; the knowledge base builds locally, so a fresh clone starts empty.

⚠ Authorized use only

A real offensive tool — with C2, evasion and a live Windows/AD path. Run it only against systems you own or have explicit written permission to test. In engagement mode, your approval is the only thing bounding where a command goes.

Clone it. Bring the stack up.

The repo ships code only — the knowledge base is kept private, so a fresh clone starts empty. Build your own, or message me for full access. It won't hunt without one.

$ git clone https://github.com/Zaidzyy/HackPit && cd HackPit $ docker compose -f docker/docker-compose.yml up -d # → localhost:3000 · cockpit ready · KB: bring your own (or ask me)
Open the repository →