CyberStrikeAI Breakdown: How the AI-Native Security "Execution Hub" Governs Agents

1. At a Glance: Worth Your Time?

Recommendation: ★★★★☆ (4.5 / 5)

The reason for this score: it’s one of the few AI security execution platforms that bake governance into the main loop — not yet another “LLM demo wrapping nmap.” Half a star off because the deployment and tuning cost is non-trivial. You need a working model API, tolerance for a Go-centric stack, and a working authorization process around it.

Key Facts (as of 2026-09-18)

Who It’s For

One-line verdict: it serves “teams with a process,” not “individuals who want a one-click report.”

Forking & Customization

Allowed? Yes. Apache-2.0 is permissive: commercial use, modification, and closed-source redistribution are all fine. You only need to retain copyright notices and document changes.

Hard? Layered:

For most users, adding tool recipes + adding roles is all you’ll need, and you barely need to write any code.

2. What It Is — and What It Isn’t

Recent AI security tools broadly split into two camps:

• Evaluation camp: Garak, Promptfoo, etc. — throw probes at a model and see if it holds up; output is a score report.
• Execution camp: let Agents actually pick up nmap, sqlmap, nuclei and do work.

CyberStrikeAI belongs to the second, and its self-labeling is accurate — an execution hub, not a scanner.

Turn intent into governed action. Turn evidence into operational memory. Let every action improve the next one.

That sentence is the project’s main thread, and it’s the key to understanding everything else.

3. Tech Stack and the Six-Stage Loop

Frontend is a built-in web console; a Burp Suite plugin and a Chrome/Edge extension are also provided (capture traffic from DevTools and feed it back).

1
2
3
4
5
6

1 Intent ──► 2 Orchestrate ──► 3 Govern
                                  │
                                  ▼
6 Memory ◄── 5 Evidence ◄── 4 Execute
   │
   └──────► Feeds next planning (dashed)

1 · Intent: natural language — e.g., “scan 192.168.1.1 for open ports.”

2 · Orchestrate: Eino supports a single agent plus three multi-agent modes — Deep, Plan-Execute, and Supervisor. Workflows are composed from five node types: Agent / Tool / Condition / Approval / Output. Note that Approval is a first-class node here, which is rare.

3 · Govern (the differentiator):

• Approval mode + tool allow-lists
• Audit Agent review + decision tracking
• MCP pre-call regex interception with probe-matching and alert templates; government-domain protection enabled by default
• Platform RBAC: multi-user, custom roles, permission scopes, resource ownership
• Login protection + audit log

4 · Execute: 100+ curated YAML tool recipes across 15 categories — network scanning, web scanning, exploitation, cloud security, forensics, post-exploitation, etc. The MCP side supports federation and dynamic tool discovery.

5 · Evidence: what the database stores is the same truncated result the Agent actually saw, and on history replay it re-enforces large-output protection so the context isn’t blown up again.

6 · Memory: a RAG knowledge base (query rewrite + vector retrieval + rerank + post-processing), progressive Skills loading for Agents, projects and attack-chain modeling (cross-session fact linking, risk scoring, graph view, step replay).

4. A Few Engineering Details That Actually Show Craft

Elastic Tool Execution: Solving “Agent Stalls”

This is the piece I think is most worth copying. Pentest tools often run for a long time (a full-port nmap, a wide nuclei sweep). If the Agent blocks synchronously, it either times out or blows the context window.

What this project does:

• Block-style MCP / tool calls are offloaded to a worker; the Agent only waits with a short deadline
• Supports multi-round wait and active cancellation via execution_id
• Per-server circuit breaking and concurrency limits
• Uniform output truncation — a 5MB tool report won’t blow up the context

Combined with the “Evidence” step above, this closes a loop: the truncated result is both what the Agent sees and what gets stored, keeping both consistent.

Vision Analysis Returns Text Summaries Only

Screenshots, CAPTCHAs, and UI go to a separate vision model; the conversation keeps only the textual conclusion. Same context hygiene.

Tool Recipes Are YAML, Not Hardcoded

100+ recipes under tools/, and adding a new tool doesn’t require Go changes. This is both an asset and a barrier — to use it well you need to audit which tools are actually installed in your environment (uninstalled ones get auto-skipped or swapped at runtime).

5. Getting Started

1
2
3

git clone https://github.com/AIPentest/CyberStrikeAI.git
cd CyberStrikeAI
chmod +x run.sh && ./run.sh

run.sh does it all in one shot: verify Go/Python envs → create venv → install Python deps → fetch Go modules → build → start. By default it runs on HTTPS with a self-signed cert on port 8080 (more stable for multi-channel scenarios); pass --http for plain HTTP.

The console prints the initial admin password on first start — change it as your first action.

A minimal config only needs one AI channel:

1
2
3
4
5
6
7
8
9
10
11

server:
  host: "127.0.0.1"
  port: 8080
ai:
  default_channel: openai-main
  channels:
    openai-main:
      provider: openai_compatible
      api_key: "${OPENAI_API_KEY}"
      base_url: "https://api.openai.com/v1"   # or any OpenAI-compatible endpoint (deepseek, qwen, …)
      model: "gpt-4o"

Upgrade with ./upgrade.sh — it backs up config.yaml and data/ first, and won’t overwrite your local tools/, roles/, or skills/.

6. Boundaries and Risks

These need to be said out loud:

• Built-in WebShell management and C2 (listeners, encrypted beacons, sessions, task queues, payload helpers) — these are unambiguously high-risk capabilities
• The README repeatedly emphasizes: use only on systems you own or for which you have explicit authorization
• Default bind is 127.0.0.1. Before exposing it elsewhere, read the security and exposure-hardening guides

Whether a project like this is worth deploying doesn’t hinge on the feature table — it hinges on whether you already have an authorization process and operational audit in place. CyberStrikeAI’s win is that approval, interception, RBAC, and audit logs are built into the product, not left for users to bolt on.

7. One Sentence

Its edge isn’t “how many tools it can call” — 100+ recipes are something anyone can collect in time. The edge is whether it dares to let the Agent really act, and whether what’s left behind is an auditable, reusable record.

Project: https://github.com/AIPentest/CyberStrikeAI · Apache 2.0 · Added to the 404 Starlink Project

This article is the long-form analysis for Scanners-Box Daily AI Tool Picks.