█

AI/TLDR

Buy me a coffee
Buy me a coffee

Cybermes

An offensive-security agent that runs bug-bounty recon, proves findings with PoC scripts and writes the report

Security AgentsOpen source
Language
Python
License
Apache-2.0
IN SHORT

What is Cybermes?

Cybermes is an open-source framework for authorised bug-bounty hunting, reconnaissance and vulnerability research. It sits in the Security Agents category of the Agents & Automation tools and is open-source, written in Python and licensed Apache-2.0. To get started: option A: add the MCP server to your AI client.

Overview

Cybermes is an open-source framework for authorised bug-bounty hunting, reconnaissance and vulnerability research. It pairs native Go utilities with more than 200 offensive-security playbooks and a set of standard recon tools (subfinder, httpx, katana, ffuf, nuclei, sqlmap), and drives them with an AI model so that one prompt such as "Assess https://example.com" turns into recon, analysis, verified findings and a written report.

Diagram of the Cybermes CLI pipeline: the operator's objective goes to the Hermes Agent, then reconnaissance, smart_pipe filtering a noisy stream into analysis with 200+ skills and offline knowledge, a validation gate that drops unverified findings, and structured reporting to SUMMARY.md, metadata.json and report.html.
The autonomous CLI pipeline, from objective to verified reportCybermes README ↗

It runs in two ways. As a standalone CLI, the built-in Hermes Agent engine (built on Nous Research's Hermes Agent) is the reasoning loop: it maps the attack surface, spawns the recon tools, reads their output and writes proof-of-concept scripts on the operating system itself. As an MCP server, `cybermes-mcp` exposes its tools, playbooks and report helpers over JSON-RPC stdio to an AI client such as Claude Desktop, Cursor, Windsurf, Cline, Roo Code, Codex or Gemini/Antigravity, and the client's model does the reasoning.

Two pieces of plumbing carry the design. `smart_pipe` is a Go stream filter that archives raw crawler and fuzzer output to disk and passes only relevant endpoints, status codes and leaked secrets into the model's context, so thousands of 404 lines never reach it. A validation gate then requires a standalone, non-destructive Python PoC (`pocs/poc_<vuln>.py`) with captured HTTP evidence before a finding is recorded. Every target gets its own `recon/` and `reports/` workspace, compiled into `SUMMARY.md`, `metadata.json`, an HTML report and a PDF.

This is offensive-security tooling, built for systems you are authorised to test. The project is Apache-2.0 licensed and runs on Linux, macOS, Windows and Docker.

What it does

  • Two modes: an autonomous Hermes Agent CLI, or a Go MCP server (`cybermes-mcp`) for AI coding clients
  • One-command MCP install that detects and configures supported clients (`npx -y cybermes-mcp install`)
  • 200+ offensive playbooks in `skills/`, covering API flaws (IDOR/BOLA, JWT), web bugs (SSRF, XSS, SQLi, race conditions) and cloud misconfigurations
  • Offline knowledge search (`search_knowledge`) across the playbooks plus PayloadsAllTheThings and HackTricks material
  • `smart_pipe` filters tool output down to high-signal lines before it enters the model's context
  • PoC validation gate: a finding is logged only with a standalone non-destructive script and raw HTTP evidence
  • Recon pipelines for subfinder, httpx, katana, ffuf, nuclei and sqlmap, plus a `secret_scan` credential scanner
  • Per-target workspaces and reports in Markdown, JSON, HTML and PDF
  • Native installers for Linux, macOS and Windows PowerShell, a Docker Compose setup and a `doctor.py` health check

Getting started

Use Cybermes inside your AI client through MCP, or install the standalone CLI. Only point it at targets you are authorised to test; the repository ships a mock vulnerable app for a first run.

Diagram of the Cybermes MCP architecture: external AI clients such as Claude and Cursor connect to the Cybermes MCP server, which fronts a security core of recon, smart_pipe, knowledge, validation and reporting modules over subfinder, httpx, katana and nuclei.
In MCP mode the AI client reasons and Cybermes runs the toolsCybermes README ↗

Option A: add the MCP server to your AI client

The installer detects supported clients and registers the server; flags limit it to specific clients.

bashbash
# configure every detected AI client
npx -y cybermes-mcp install

# or only some of them
npx -y cybermes-mcp install --gemini --cursor

Or register it by hand

Add the server to the client's mcpServers section.

jsonjson
{
  "mcpServers": {
    "cybermes": {
      "command": "npx",
      "args": ["-y", "cybermes-mcp"]
    }
  }
}

Option B: install the standalone CLI

On Linux or macOS, clone the repository, run the installer and put your API keys in .env (Windows uses setup_windows.ps1).

bashbash
git clone https://github.com/Zyrexnn/Cybermes.git
cd Cybermes
./setup.sh
nano .env

Check the environment

doctor.py verifies dependencies and tool paths; --fix repairs missing components.

bashbash
python tools/doctor.py
python tools/doctor.py --fix

Run a first assessment against the bundled mock app

Findings, PoCs, evidence and reports land in reports/<target>/.

bashbash
python examples/mock_vulnerable_app.py   # serves http://127.0.0.1:8888
./cybermes "Assess http://127.0.0.1:8888"

Commands and code are distilled from the project's own documentation — always check the official repo for the latest.

When to use it

  • Reach for it to run authorised bug-bounty reconnaissance end to end from a single prompt, with findings written up as reports
  • Reach for it when you want Claude, Cursor or another MCP client to drive recon and secret scanning without pasting terminal output into the chat
  • Reach for it when you need every reported vulnerability backed by a reproducible PoC script and HTTP evidence
  • Reach for it to practise agent-driven web testing on the bundled mock vulnerable app before pointing it at a scoped target

How Cybermes compares

Cybermes alongside other open-source security agents tools AI/TLDR tracks, ranked by GitHub stars.

ToolStarsWhat it does
REA★ 464kOpen-source CLI and MCP server that lets coding agents reverse engineer apps locally, decompiling native binaries via Hopper or Ghidra and analysing JavaScript/Electron apps, recording each finding as reproducible evidence.
PentAGI★ 34.3kPentAGI is a self-hosted AI security platform that plans and runs penetration tests autonomously using a team of agents and 20+ built-in pentesting tools.
PentestGPT★ 16.4kAn open-source agent that uses large language models to run penetration tests and solve security challenges, either fully autonomously or with a human in the loop.
HexStrike AI★ 13.7kAn MCP server that gives an AI agent a single interface to 150+ installed security tools — Nmap, Nuclei, SQLMap, Ghidra, Hashcat and more — so it can drive reconnaissance, scanning and binary analysis itself.
IDA Pro MCP★ 13.5kAn MCP server and IDA Pro plugin that exposes decompilation, cross-references, renaming and type editing to an LLM client, letting an agent read and annotate a binary inside your IDA database.
CAI★ 9.9kCAI (Cybersecurity AI) is an open-source Python framework for building AI agents that automate offensive and defensive security tasks like recon, vulnerability discovery, and exploitation.
AiSOC★ 8kA self-hostable AI Security Operations Center that ingests security telemetry, correlates detections into incidents and has LLM agents triage them, logging every step to an auditable ledger.
Cybermes★ 1kAn offensive-security agent that runs bug-bounty recon, proves findings with PoC scripts and writes the report