---

Overview

AntiFox is an AI-driven autonomous penetration testing platform. Given an authorized target, a planner / worker / main-agent multi-agent system runs the full engagement over a dual-graph core (a global asset graph + a per-task exploration graph) — recon → attack-surface discovery → exploitation → finding capture → report delivery — fully observable, interactive, and deliverable.

Unlike most automated pentest tools that are "great at discovery, but stop at discovery," AntiFox puts its weight on delivery — turning what the AI finds into a report that an engineer can understand, reproduce, back with evidence, and hand straight to the client.

✨ What's New in v2.0: Evidence-Driven Delivery

v2.0 is about one thing — turning "can find it" into "can deliver it." The agent fixes the reproduction steps and evidence in place while it works, so the engineer's job shifts from "assembling a report from scratch" to "verify and confirm."

① Reproduction captured in place. As the agent exploits, each step's request, response, expected outcome, and verification conclusion are recorded as structured data — not reconstructed after the fact — eliminating the old "incomplete or fabricated reproduction" problem.

② Findings laid out as a kill chain. A finding is no longer "one command plus a verdict," but a full chain from entry point and preconditions through each exploitation step, each in plain language paired with a real request — so an engineer opening the finding immediately grasps where it came from and how it was chained.

③ Every step auto-linked to its real traffic. All requests the agent makes are captured in full via MITM recording; when a finding is recorded, the system links each step to its corresponding real packet by time window and step order. One click shows the original request/response, with syntax highlighting, body search, and match counts — no need to go back to a proxy tool and reconstruct it.

④ The packet is the evidence. For findings like sensitive-information disclosure, the traffic packet itself is the proof — no more stitching together screenshots afterwards.

⑤ Human-grade trilingual reports. AI narrative + python-docx rendered into a delivery-grade .docx (cover / TOC / page numbers / per-vuln tables with structured reproduction), as a full report in Simplified Chinese / Traditional Chinese / English.

All UI data shown is synthetic demo data from a local test range.

Quick Start

Requires PostgreSQL; exploration needs an LLM (ANTHROPIC_API_KEY or OPENAI_API_KEY, or configure it in the UI). Generating .docx reports needs python3 + python-docx (bundled in the Docker image).

Option 1: One-command Docker deploy (recommended)

curl -O https://raw.githubusercontent.com/AntiFox-AI/antifox/main/docker-compose.yml
curl -O https://raw.githubusercontent.com/AntiFox-AI/antifox/main/.env.example
cp .env.example .env          # set POSTGRES_PASSWORD
docker compose up -d          # pulls the image + PostgreSQL and starts

Open http://localhost:8787 — on first run, go to /setup to set the admin password.

Option 2: Prebuilt binary

Download the zip for your platform from Releases (Linux amd64/arm64 · macOS amd64/arm64 · Windows amd64), then:

cp config.example.json config.json    # fill in the database connection
./antifox                             # antifox.exe on Windows

Open http://localhost:8787.

Option 3: Build from source

The full source is open (AGPL-3.0). Requires Go 1.24+ / Node 20+ / PostgreSQL / Python 3 (report rendering):

cd web && NEXT_EXPORT=1 npx next build && cd ..    # frontend static export
cp -r web/out/. server/webui/dist/                 # embed the frontend
CGO_ENABLED=0 go build -tags embedui -o antifox ./cmd/antifox
./antifox

Full steps (skill embedding, dev hot-reload) are in CONTRIBUTING.md.

One-click update: for a binary/source deploy, launch via ./start.sh or systemd (see deploy/antifox.service, set RestartForceExitStatus=75) to check for and install new versions from System Settings (SHA256 verify / atomic swap / rollback; data unaffected). For Docker, use docker compose pull.

More Screens

Dashboard	Tasks

Lineage

AntiFox is a fork that started from v0.1.1 of the open-source project ARTEX (by @Autumn-27), tracking upstream ever since, with mutual exchange along the way. Full credit to the original author's foundational work.

To be clear, "autonomous discovery" and "report delivery" are two different goals: ARTEX made discovery strong, while delivery is closer to each specific engagement and varies by client. AntiFox builds on that solid foundation and invests its engineering effort in the "delivery" half.

What AntiFox Adds (vs ARTEX)

Building on its solid foundation (exploration-graph engine, MITM traffic recording, rule-based HITL interception, multi-agent orchestration), AntiFox mainly adds: