Jane fights the engagement — she doesn't run a fixed scan
A bounded ReAct loop drives every mission: she reasons a move, picks one scope-gated weapon, observes what it hit, and presses the advantage — forming hypotheses, testing them under fire, and promoting only the proven ones to findings. A miss is kept as intel, never discarded.
Reason
Calls the shot — states a hypothesis and why the next strike is in-scope and safe.
Strike — gated
Fires one tool through the policy gate. Out-of-scope shots are refused, not sent.
Observe
Reads the captured exchange; the request/response is logged as evidence.
Adapt
Reads the failure — backs off a rate-limit, re-auths a 401, pivots the class. A blocked path becomes a revisitable gap, never a dead end.
Confirm the kill
Promotes a proven breach to a finding — CWE, MITRE ATT&CK, CVE and CVSS, with a one-click curl to reproduce.
The offensive advances phase by phase — and only when the gate falls
Jane wages a real campaign, not a checklist. Each phase pulls its own framework playbooks and must breach a validation gate before the next front opens. Escalation into post-exploitation is authorized separately — a surface-only mission documents and holds the line.
Scout the ground
Enumerate endpoints, params and tech.
Find the weak point
Probe authn/z, injection, IDOR, SSRF.
Take the ground
Confirm the breach with reproducible evidence.
Press deeper — if authorized
Escalate within the granted depth.
The after-action
Findings + kill-chain coverage.
One engine, three engagement modes
Pick how Jane carries herself on the target. The mode dials how she operates within the grant — it never widens scope or bypasses the gate. Scope and authorization are enforced on every single move, in every mode.
Authorized
Scope-gated, evidence-first testing at the depth your policy allows. The default — a disciplined assessment that documents what it proves and holds the line at the granted depth.
Bug bounty
Obeys a program's pasted rules of engagement and excluded vuln classes, minimises data access, paces politely, and reports in a triage-ready shape — VRT priority, repro and impact ready to paste into HackerOne or Bugcrowd.
APT emulation
Full ATT&CK TTP depth — chain, pivot, persistence, lateral movement, and defense-aware pacing to test what your detection actually catches. The most aggressive profile, and still bounded by the authorization and scope you set on every run.
Hand Jane a finding — she proves it or clears it
Already have a report? Paste a pentest or bug-bounty write-up (a HackerOne submission, any markdown) and Jane validates it instead of hunting from scratch. She parses each claim and the scope it targets, reproduces it with the same scope-gated weapons and headless browser — self-registering through AgentMail when the issue sits behind a login — and returns a verdict backed by replayable evidence. Shipped a fix? Re-run to prove the patch holds.
Paste the report
Drop in one or more markdown reports. Jane extracts the concrete, testable claims and the scope they target — no manual setup.
Reproduce — gated
She re-runs each claim through the policy gate, browser-proving client-side bugs and authenticating when the target demands it, logging every step.
Verdict + evidence
Reproduced, not reproduced, or inconclusive — each with evidence tagged to the validation and linked to its task for a clean chain of custody.
Re-validate the fix
After the patch, one click re-tests: a confirmed issue that now comes back clean is your remediation proof.
Watch the assault unfold, in real time
Operators command missions from a board and follow Jane live on the front: her reasoning trace, the hypothesis timeline, kills as they’re confirmed, and a coverage map of every position taken.
A gated armory: expert playbooks, real recon tools, and a methodology corpus
Jane never fights from nothing. For the active phase and the target in front of her she draws the matching vuln-class playbook, seeds every applicable OWASP WSTG test from the discovered surface, and — scope-gated to the target — commands a real recon/scan toolchain. The framework packs are built independently from public sources and Ed25519-signed, so a tampered pack never makes it to the field.
Jane plugs into the stack you already fight with
She doesn’t just report — she acts through your tools: reading your source for white-box analysis, shipping the fix, verifying bug-bounty reports, filing engineering tickets in Jira, sounding the alarm, and commanding the scanners you already trust. Every integration stays inside the same scope and audit log as the rest of the engagement.
One operator, your whole stack. Jane reads your repos, commands the scanners, verifies incoming HackerOne bug-bounty reports, sounds the alarm in chat, runs her own agent inboxes, and files engineering tickets in Jira — all driven by the LLM you choose, inside one scope and audit log.
Reads the source, ships the fix
Connect a repo and Jane can pull the code to run white-box analysis alongside the live attack (optional) — then open an auto-fix pull or merge request for a confirmed finding, patch and evidence attached, scoped to the repos you install her on.
Sounds the alarm in Slack
Point Jane at a channel and every confirmed kill, mission milestone and escalation lands where your team already lives — with the evidence attached and a jump straight into the war room. No dashboard-watching required.
Commands Burp — not just scans
Connect over Burp's MCP server and Jane drives the whole toolkit — Intruder, Repeater, the Proxy history and the sitemap, not only the REST scanner. Works with Burp Pro on your machine (via a no-ports connector) or a cloud/Enterprise deployment. Every target-touching call is scope-gated, and she replays and re-proves each lead with her own reproducible evidence before it ever counts as a finding.
Verifies bug-bounty reports
Pull in submissions from your HackerOne program and Jane re-tests each one against the live target inside your scope — reproducing the claim, capturing the evidence, and telling you which reports are real, which are duplicates, and which don't hold up. Triage on proof, not on how convincing the write-up sounds.
Files the engineering ticket
Every validated finding becomes a Jira ticket for the team that owns the fix — severity, repro steps, evidence and remediation already written up — and its status syncs back to Jane, so you can see what's fixed without chasing anyone.
Point Jane at 100+ models — on your keys, your subscription
Jane runs on the platform's shared keys out of the box. Or bring your own: set a provider, model and key per mission so every token is billed to — and every byte stays on — your org's own AI account. Twenty providers ship curated, and any OpenAI-compatible endpoint works, so you can reach well over a hundred models.
Bring your own keys
Override per mission with your org's provider, model and key. Your data never touches the platform's AI accounts — it stays on the subscription you control. Keys are stored encrypted and never shown again.
Automatic failover
A per-agent provider chain with your mission keys first, then the platform behind them. A rate-limit, quota wall or content-filter refusal rolls over to the next provider — the engagement never stalls on one model.
Add any model, no redeploy
Type any model id a provider serves — new releases work the moment they ship, with no deploy and no waiting on us. Point at a self-hosted vLLM or Ollama endpoint by URL and Jane speaks to it the same way.
Built so an autonomous attacker can be trusted on a real target
A weapon this capable is only safe when it’s bounded and accountable. Jane is built around the scope you grant, the evidence she captures, and the identity of who gave the order.
Deny-by-default scope
Allowed hosts, ports, paths and methods are the front line. Every target-touching call is gated twice; an out-of-scope shot is refused before it leaves.
Proof of every kill
Findings carry replayable exchanges, a runnable PoC, a CVSS breakdown and counterevidence — cleared through a multi-gate validator before they confirm.
Chain of command
Authenticator MFA and passkeys, scoped API keys, and mission-scoped users — with an audit log of who gave the order, changed it, and read the results.
Give the order
Set a scope, authorize the campaign, and watch Jane go to war on it — live, evidence-backed, and inside the lines you drew.