RedAmon Turns 100 Security Tools Into an Open-Source AI Hacking Pipeline
A trending open-source framework chains reconnaissance, exploitation, and post-exploitation into one autonomous agent pipeline with human oversight gates.
Takeaways
- RedAmon is an MIT-licensed agentic red team framework trending on GitHub with 2,700+ stars.
- Chains reconnaissance, exploitation, post-exploitation, AI triage, and automated GitHub pull request fixes.
- Built on LangGraph, Neo4j knowledge graph, MCP tool servers, and 100+ integrated security tools.
- Supports OpenAI, Anthropic, Bedrock, OpenRouter, plus local Ollama and vLLM endpoints.
- Ships STRIDE threat model, non-disableable guardrails blocking government targets, and human-in-the-loop approval gates.
- Runs fully containerized via Docker Compose; requires 4-8 GB RAM minimum, 16 GB with OpenVAS.
RedAmon has attracted thousands of GitHub stars with an open-source framework designed to coordinate an authorized security assessment from reconnaissance through a proposed code fix. Created by Samuele Giampieri and maintained with security researcher Ritesh Gohil, the project combines roughly 100 security tools, a LangGraph agent, a Neo4j attack-surface graph, and a web interface in one Docker Compose stack.
The MIT license makes the framework available for modification and self-hosting. Its broad scope explains much of the interest: RedAmon discovers assets, selects offensive tools, records attack paths, triages findings, edits source code, and opens a GitHub pull request. Human reviewers still decide whether a proposed patch is safe and ready to merge.
Red teaming simulates an attacker’s behavior under explicit authorization. RedAmon automates parts of that process with a large language model, so its value depends on target scope, model quality, tool configuration, and operator oversight. The project’s popularity establishes developer interest; repeatable benchmarks against skilled human testers would establish effectiveness.
Authorization required: Run RedAmon only against systems you own or have explicit written permission to test. Its scanners and exploitation tools can disrupt services, alter data, and trigger security controls.
Six components, one operating stack
RedAmon isolates its major services in Docker containers and connects them through APIs. This structure keeps scanners, agents, storage, and remediation logic separate while giving the orchestrator one shared view of the engagement.
| Component | Role |
|---|---|
| Reconnaissance pipeline | Runs subdomain discovery, port scanning, HTTP probing, resource enumeration, and vulnerability detection in parallel. |
| AI Agent Orchestrator | Uses LangGraph to query findings, choose tools, move through engagement phases, and accept operator instructions through chat. |
| Attack Surface Graph | Stores assets, findings, and relationships in Neo4j using 17 node types and more than 20 relationship types. |
| EvoGraph | Persists attack chains and prior observations across sessions to reduce duplicate work. |
| CypherFix | Triages graph findings, proposes source-code changes, and opens GitHub pull requests. |
| Project Settings Engine | Exposes more than 500 project-level controls through the web interface. |
From asset discovery to pull request
The documented workflow follows six stages:
- Reconnaissance: Kali-based containers discover hosts, services, URLs, and potential vulnerabilities.
- Graph ingestion: Background workers stream results into Neo4j as connected assets and findings.
- Exploitation: The agent queries the graph, selects an available tool, and evaluates the result before choosing another action.
- Post-exploitation: Approved tools inspect the access and relationships exposed by a successful exploit.
- AI triage: Cypher queries and an LLM deduplicate findings and rank them by exploitability.
- Remediation: The CodeFix agent edits a cloned repository and submits the proposed change as a pull request.
The agent follows a ReAct-style loop, alternating between model reasoning and tool execution. It can invoke Nmap, Nuclei, Metasploit, Hydra, Playwright, ffuf, and a Kali shell through Model Context Protocol servers. MCP provides a standard interface through which an agent can discover and call external tools.
Each project also receives an isolated workspace with 24 filesystem tools and five background-job tools. Long scans can run asynchronously while the agent searches their live logs, preserving the reasoning loop for other work.
Fireteam keeps parallel agents bounded
RedAmon’s Fireteam system implements a Scatter-Gather ReAct pattern. A root agent decides when a task benefits from parallel work, dispatches a bounded group of specialist agents, and consolidates their results into one updated view of the target.
Several controls limit agent sprawl. Sub-agents cannot create additional agents, and each wave has a maximum team size, iteration budget, and wall-clock timeout. These limits constrain cost and execution time while reducing the chance of recursive agent chains consuming resources indefinitely.
CypherFix crosses into remediation
CypherFix extends the engagement beyond vulnerability reporting. Hardcoded Cypher queries select relevant graph data, an LLM groups duplicate findings and estimates exploitability, and the CodeFix agent clones the target repository to locate and patch the affected code.
The cloned repository is untrusted input, so build and test commands execute in an isolated container without secrets. The GitHub token remains outside that sandbox. This boundary reduces the exposure created by malicious build scripts, compromised dependencies, or repository content designed to influence an automated agent.
Generated patches still require normal engineering controls: code review, reproducible tests, dependency checks, and deployment approval. A plausible edit can introduce regressions or address the symptom while leaving the underlying vulnerability reachable through another path.
Broad model support and local retrieval
RedAmon supports OpenAI, Anthropic, OpenRouter, AWS Bedrock, and OpenAI-compatible endpoints such as Ollama, vLLM, and LM Studio. It fetches available models from configured providers and exposes a reasoning-effort setting for models that support it. When an endpoint rejects that parameter, the framework retries the request without it.
An optional retrieval-augmented generation system indexes security references including GTFOBins, LOLBAS, the OWASP Web Security Testing Guide, NVD CVEs, ExploitDB, and Nuclei templates. RAG supplies relevant source material to the model before it answers or selects an action.
The knowledge base combines FAISS vector search with Neo4j full-text search, then applies a cross-encoder reranker to order results. High-confidence local matches can replace a web search. Operators can send embedding work to an OpenAI-compatible API when local ingestion would consume excessive CPU time.
Guardrails around high-impact tools
RedAmon’s documentation describes a STRIDE threat assessment covering spoofing, tampering, repudiation, information disclosure, denial of service, and elevation of privilege. The stated hardening measures include service-level privilege separation, a filtering broker in front of the Docker socket, fail-closed authentication, server-side request forgery controls, secret redaction, and append-only audit records.
- Rules of Engagement: Operators can upload scope and restrictions as PDF or Markdown.
- Approval gates: Individual tools can require human confirmation before execution.
- Passive mode: Stealth settings restrict the available actions to passive collection.
- Phase controls: Tools such as
proxy_replayandproxy_fuzzrequire the appropriate engagement phase and manual approval. - Target restrictions: A fixed guardrail blocks government, military, and intergovernmental targets.
- Service isolation: Tools, scanners, and agents run in separate containers without direct host execution.
Containers share the host kernel, and the platform deliberately grants powerful services network and tooling access. A dedicated host or virtual machine, restricted egress, short-lived credentials, and centralized logging provide additional containment. Teams should also review what target data reaches an external model provider before selecting a hosted LLM.
Deployment fit and operating costs
| Scenario | Assessment | Reason |
|---|---|---|
| Authorized penetration tests | Strong fit | The framework coordinates broad tool coverage and can route validated findings into code review. |
| Internal staging environments | Strong fit | Persistent graph data can reduce repeated discovery work across scheduled assessments. |
| CVE validation on owned infrastructure | Reasonable fit | Operators can combine targeted scanning, exploitation, and evidence collection in one workspace. |
| Production systems | High-control use only | Exploitation and post-exploitation can alter state or interrupt services, requiring narrow scope and approval gates. |
| Third-party systems without written permission | Prohibited | Scanning or exploitation may violate law, contracts, and provider policies. |
The full stack has substantial resource requirements. A deployment with OpenVAS calls for at least four CPU cores, 16 GB of recommended memory, and roughly 250 GB of storage for an always-on server. The initial Greenbone Vulnerability Management feed synchronization can take about 30 minutes. LLM requests, embedding jobs, and commercial OSINT APIs can add usage-based costs.
Installation starts with Docker Compose
A local installation requires Docker Compose v2 and three shell commands:
git clone https://github.com/samugit83/redamon.git
cd redamon
./redamon.sh install
LLM and OSINT credentials are configured in the web interface at localhost:3000/settings. Supported OSINT integrations include Tavily, Shodan, Censys, and VirusTotal. Keeping configuration in the interface centralizes project settings, though operators should still use scoped, revocable API keys.
For an internet-reachable instance, the project provides a single-host deployment with nginx, Let’s Encrypt TLS, a host firewall, and fail2ban. Internal services bind to the loopback interface. Exposing an autonomous security platform warrants additional controls such as identity-aware access, network allowlists, backups, monitoring, and routine image updates.
Traction leaves a benchmark question
RedAmon packages reconnaissance, exploitation, post-exploitation, remediation, graph-based memory, and a web interface in one open repository. That breadth distinguishes it from narrower scanners and from research agents that lack deployment tooling or a documented threat model.
GitHub stars measure interest; effectiveness requires public evaluations of exploit accuracy, false-positive rates, patch quality, model cost, and performance against experienced operators. Until those results exist, RedAmon is best assessed as an ambitious integration platform whose outputs and actions require close human supervision.