Autonomous Bug-Bounty Pipeline

First live engagement: 55 hypotheses closed, 3 findings triaged on the platform. The pipeline ran end-to-end on a public Cantina program covering four Solidity contract suites. Every hypothesis was either struck with quoted-code rationale or confirmed with a passing Foundry proof-of-concept on a local blockchain fork. Three findings were submitted and received triage scores: one Medium and two Low severity. One Low finding pinned 634 USDC.e stranded in a deployed contract.

Watches four bounty platforms and starts the deep audit the moment scope changes, with no human in the loop until findings exist. Public bug-bounty programs run on a first-to-report model. A scope change quietly added to a live program is worth more than racing the field on a fresh launch, but catching it within minutes and immediately running a deep adversarial audit requires infrastructure that does not exist off-the-shelf.

The watchdog polls Cantina, Code4rena, Sherlock, and HackerOne using their public APIs. For each program it computes a scope hash over asset names, reward tiers, and rules, so a silently-added contract fires a SCOPE CHANGED event even when the platform makes no announcement. On a trigger it fans alerts across 5 channels in parallel: ntfy push, Telegram, email (SMTP), GitHub issue (which doubles as the acknowledgment channel), and a Twilio voice call that re-dials every 15 minutes until the operator closes the issue.

The orchestrator receives the event, renders a structured workspace (scope, known-issues pulled from prior audit PDFs, attack-surface checklist), creates one git worktree per checklist block so workers never share a checkout, then spawns one supervisor per worker. Each supervisor runs claude -p in headless stream-JSON mode, scans output for completion claims, idle timeouts, API usage limits, and any attempt to submit, and responds appropriately: nag the worker back to the next unchecked item, sleep to the quota reset time and resume the same session, or flag a submission attempt loudly for the operator.

It runs the work no person can keep up with: nine attack surfaces audited in parallel, hundreds of hypotheses tracked at once. The checklist driving each worker covers nine blocks: reentrancy and callback surfaces, signature replay, arithmetic and accounting invariants, oracle trust, access-control archaeology, deployment archaeology (bytecode-vs-source diffs and silent-fix analysis across git tags), cross-contract emergent behavior, invariant fuzzing, and web/app scope.

Each worker owns exactly one block in its own isolated copy of the code. Workers append every hypothesis and verdict to a live STATUS.md, and that file is how the supervisor measures progress between nags. The overseer tracks all worker processes, restarts any that crash, and writes a SWARM_STATUS.md each pass so the operator has a single dashboard for the entire swarm.

Nothing reaches a platform without a human clicking submit, and every proof-of-concept runs on a safe local copy of the chain. A worker that attempts to reach a submission endpoint is flagged with a .SUBMISSION-ATTEMPT-* marker and the operator is notified immediately. The operator gets a phone call that re-dials until acknowledged, reviews the drafted findings in the workspace, and decides what to submit.

The test suite enforces this guarantee with no network calls: httpx.MockTransport for all HTTP, a scripted _fake_claude.py shim that emits programmed stream-JSON output for supervisor testing, and throwaway SQLite databases under tmp_path. Zero API spend, zero network calls. The full pipeline runs offline before any real engagement.

The whole pipeline was built and tested in two days, 19 commits, then a live engagement. 6.2k lines of Python across watchdog/, orchestrator/, and tests/. Adding a new platform requires writing exactly one file (a source adapter implementing a single fetch() method) and touching nothing else in the poll loop, notify fan-out, or worker scaffold.