Skip to content
Back to search

red-run

SkillWorks with Claude CodeGitHub

Offensive security toolkit for Claude Code

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/blacklanternsecurity/red-run with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/blacklanternsecurity/red-run'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/blacklanternsecurity--red-run/badge.svg)](/listings/blacklanternsecurity--red-run)

HTML

<a href="/listings/blacklanternsecurity--red-run"><img src="/api/listings/blacklanternsecurity--red-run/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

**Prerequisites:** Linux VM with pentesting tools, [Claude Code](https://docs.anthropic.com/en/docs/claude-code), [uv](https://docs.astral.sh/uv/), [Docker](https://docs.docker.com/engine/install/). Optional: [Sliver](https://github.com/BishopFox/sliver) for C2 integration.

./install.sh          # Symlink-based (edits reflect immediately)
./install.sh --copy   # Copy-based (standalone machines)
./uninstall.sh        # Remove everything

The installer sets up the orchestrator, teammate templates, and MCP servers, indexes `skills/` into ChromaDB for semantic retrieval, and starts the shell-server. The repo must stay in place — skill-router reads from `skills/` at runtime.

After installing, run the preflight check to verify attackbox dependencies (nmap, ffuf, sqlmap, hashcat, impacket, etc.):

bash preflight.sh

Then launch:

./run.sh              # shell-server only (default)

C2 integration (optional)

red-run works out of the box with shell-server (raw TCP reverse shells + interactive processes). For C2 support, run the config wizard before launching:

bash config.sh             # select C2 backend, generate operator configs
./run.sh                   # starts C2 daemon + MCP automatically

`config.sh` writes `engagement/config.yaml` and patches `.mcp.json` with the C2 MCP server entry. The orchestrator skips its built-in config wizard when `config.yaml` exists. Currently supported: Sliver. Custom C2 integration via operator-provided MCP servers is also supported.

The shell-server runs as a persistent SSE service (`127.0.0.1:8022`) shared across all teammates — sessions created by one teammate are visible to all others. `run.sh` starts it automatically and is idempotent (safe to re-run). A `SessionStart` hook also attempts auto-start as a fallback.

See [dependencies](docs/dependencies.md) for the full list of required tools.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 144 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # red-run
  2. ## **!!! This project is archived and no longer maintained. Use at your own risk. !!!**
  3. Security assessment toolkit for Claude Code.
  4. <p align="center">
  5. <img src="docs/banner.png" width="700" alt="red-run banner">
  6. </p>
  7. red-run combines skills, MCP servers, and Claude Code agent teams with routing logic that guides Claude and the operator through the phases of a security assessment — recon, initial access, lateral movement, privilege escalation, and post-access. It tracks engagement state in a SQLite database that persists across context compactions, routes to skills via semantic search (RAG), and delegates execution to persistent domain teammates that accumulate context across tasks.
  8. The orchestrator (team lead) presents the assessment surface, chain analysis, and available paths — you choose what to test next. Teammates work in their own tmux panes where you can watch them, press Escape to interrupt, and type directly to redirect. See [Agent Teams](#agent-teams) below for setup.
  9. ## Orchestrators
  10. red-run supports multiple orchestrator variants that share the same skills, MCP servers, and engagement state. Each variant targets a different use case. Community contributions welcome.
  11. | Orchestrator | Trigger | Status | Purpose |
  12. |---|---|---|---|
  13. | `/red-run-ctf` | `/red-run-ctf` | **Active** | CTF and lab environments. Agent teams with persistent teammates, full autonomy. |
  14. | `/red-run-legacy` | `/red-run-legacy` only | **Legacy** | Original subagent-based orchestrator. Ephemeral agents, one skill per invocation. |
  15. | `/red-run-notouch` | `/red-run-notouch` only | **Planned** | DLP-safe mode. The operator executes commands in separate tmux panes and reports sanitized output back to the orchestrator. No client data touches Anthropic servers. |
  16. | `/red-run-train` | `/red-run-train` only | **Planned** | Training mode. Guided walkthrough with explanations at each step. Designed for learning security assessment methodology with AI assistance. |
  17. All orchestrators write to the same `engagement/state.db` — an engagement started with one variant can be resumed with another.
  18. ## Documentation
  19. Full documentation is available at the [docs site](https://blacklanternsecurity.github.io/red-run/):
  20. - [Architecture](https://blacklanternsecurity.github.io/red-run/architecture/) — platform vs strategy layers, prompt architecture, data flow
  21. - [Installation](https://blacklanternsecurity.github.io/red-run/installation/) — prerequisites, setup, sandbox configuration
  22. - [Running an Engagement](https://blacklanternsecurity.github.io/red-run/running-an-engagement/) — end-to-end operator guide
  23. - [MCP Servers](https://blacklanternsecurity.github.io/red-run/mcp-servers/) — nmap, shell, browser, state, skill-router
  24. - [Writing Skills](https://blacklanternsecurity.github.io/red-run/writing-skills/) — contributor guide for new skills
  25. See also: [Skills Inventory](docs/skills-inventory.md) for the full skill inventory.
  26. ## Installation
  27. **Prerequisites:** Linux VM with pentesting tools, [Claude Code](https://docs.anthropic.com/en/docs/claude-code), [uv](https://docs.astral.sh/uv/), [Docker](https://docs.docker.com/engine/install/). Optional: [Sliver](https://github.com/BishopFox/sliver) for C2 integration.
  28. ```bash
  29. ./install.sh # Symlink-based (edits reflect immediately)
  30. ./install.sh --copy # Copy-based (standalone machines)
  31. ./uninstall.sh # Remove everything
  32. ```
  33. The installer sets up the orchestrator, teammate templates, and MCP servers, indexes `skills/` into ChromaDB for semantic retrieval, and starts the shell-server. The repo must stay in place — skill-router reads from `skills/` at runtime.
  34. After installing, run the preflight check to verify attackbox dependencies (nmap, ffuf, sqlmap, hashcat, impacket, etc.):
  35. ```bash
  36. bash preflight.sh
  37. ```
  38. Then launch:
  39. ```bash
  40. ./run.sh # shell-server only (default)
  41. ```
  42. ### C2 integration (optional)
  43. red-run works out of the box with shell-server (raw TCP reverse shells + interactive processes). For C2 support, run the config wizard before launching:
  44. ```bash
  45. bash config.sh # select C2 backend, generate operator configs
  46. ./run.sh # starts C2 daemon + MCP automatically
  47. ```
  48. `config.sh` writes `engagement/config.yaml` and patches `.mcp.json` with the C2 MCP server entry. The orchestrator skips its built-in config wizard when `config.yaml` exists. Currently supported: Sliver. Custom C2 integration via operator-provided MCP servers is also supported.
  49. The shell-server runs as a persistent SSE service (`127.0.0.1:8022`) shared across all teammates — sessions created by one teammate are visible to all others. `run.sh` starts it automatically and is idempotent (safe to re-run). A `SessionStart` hook also attempts auto-start as a fallback.
  50. See [dependencies](docs/dependencies.md) for the full list of required tools.
  51. ## Agent Teams
  52. red-run uses [Claude Code agent teams](https://code.claude.com/docs/en/agent-teams) to coordinate multiple Claude Code sessions working together. The orchestrator runs as the team lead, spawning persistent domain teammates that each get their own tmux pane. Teammates are split into enumeration (net-enum, web-enum, ad-enum, lin-enum, win-enum) and operations (web-ops, ad-ops, lin-ops, win-ops) pairs for parallel discovery and technique execution, plus on-demand specialists (bypass, spray, recover, research). Benefits over the legacy subagent model:
  53. - **Persistent context** — teammates accumulate knowledge across tasks instead of starting fresh each time
  54. - **Teammate messaging** — teammates report findings to the lead who routes to the right specialist (e.g., web teammate finds domain creds → lead routes to AD teammate)
  55. - **Operator visibility** — watch all teammates working in split tmux panes, press Escape to interrupt any teammate, type directly to redirect
  56. - **Shared task list** — coordinated parallel work with the lead assigning all tasks
  57. Agent teams requires the Claude Code experimental feature flag. The repo's `.claude/settings.json` already includes this:
  58. ```json
  59. {
  60. "env": {
  61. "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  62. }
  63. }
  64. ```
  65. No manual setup needed — cloning the repo and running `./install.sh` is sufficient. For split-pane teammate visibility, start Claude Code inside a tmux session. Without tmux, teammates run in-process (cycle with Shift+Down - this is not recommended for optimal control).
  66. Agent teams works in standard permission mode — teammate permission requests surface to the operator for approval. The orchestrator's `AskUserQuestion` gates provide human-in-the-loop control for all routing decisions.
  67. ## State Dashboard
  68. Browser-based read-only dashboard for `engagement/state.db` with an access chain graph and live SSE updates:
  69. ```bash
  70. bash operator/state-viewer/start.sh
  71. ```
  72. Open `http://127.0.0.1:8099` to see targets, credentials, access, vulns, pivots, tunnels, blocked techniques, and an event timeline — all updating in real-time as teammates work. The access chain graph supports fullscreen mode for detailed review.
  73. To access from a host machine (when red-run is in a VM), generate an auth token — the server will bind to `0.0.0.0` and require the token to access any page:
  74. ```bash
  75. bash operator/state-viewer/generate-token.sh
  76. ```
  77. See `operator/state-viewer/README.md` for details.
  78. ## Running
  79. ```bash
  80. ./run.sh # starts shell-server + Claude Code, loads /red-run-ctf
  81. ./run.sh --lead=legacy # loads /red-run-legacy instead
  82. ./run.sh --yolo # skip permission prompts
  83. ```
  84. Send any message (e.g., a target IP) to activate the orchestrator. The orchestrator presents routing decisions for operator approval before assigning any task. Run from an isolated VM or dedicated pentesting machine. You are responsible for containing Claude on your systems and for any legal consequences under the CFAA or equivalent legislation.
  85. ## Disclaimer
  86. **By using red-run you accept full responsibility for its actions.** This tool runs fully autonomous AI agents that execute offensive security techniques — port scanning, vulnerability exploitation, credential attacks, privilege escalation, and lateral movement — against targets you specify.
  87. - **Authorization required.** Do not use against systems without explicit written permission. Unauthorized access to computer systems is illegal under the CFAA (18 U.S.C. § 1030) and equivalent laws in other jurisdictions.
  88. - **CTF and lab use only.** The current version of the orchestrator is a CTF solver — it runs fully autonomous agents with no OPSEC considerations. Skills are baseline templates built by AI and have not been thoroughly reviewed by human eyes. Expect gaps, false positives, and techniques that need validation before use on real infrastructure. See the [architecture docs](docs/architecture.md) for the production engagement roadmap.
  89. - **No OPSEC guarantees.** Agents run with no stealth considerations. Assume all activity is logged and detectable. Do not rely on red-run for covert operations.
  90. - **Content policy warnings.** red-run's autonomous agents generate and execute offensive security commands. This may trigger Anthropic content policy warnings on your account. We are not responsible for the standing of your Anthropic account — use at your own risk.
  91. - **No warranty.** red-run is provided as-is. The authors are not liable for any damage, data loss, legal consequences, or other harm resulting from its use.
  92. ## License
  93. Copyright (C) 2026 Black Lantern Security
  94. Licensed under the GNU Affero General Public License v3.0 or later (`AGPL-3.0-or-later`). See [LICENSE](LICENSE).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.