The autonomous demo makes a nice GIF: point it at a target, watch findings roll in. But real engagements aren’t push-button, and no serious tester wants a black box. The interesting thing about CyberStrike isn’t that the AI can run an assessment end to end. It’s that you don’t have to let it.
CyberStrike is AI-augmented, not AI-only. The AI can drive, you can drive, or both of you can work the same session at once, and underneath it’s a platform you shape: your models, your agents, your playbooks, your tools, your rules of engagement. Here’s how security engineers, pentesters, and teams actually put it to work.
Two ways to drive, and you can mix them
Every assessment feeds one agent pipeline, and there are two interchangeable ways to feed it:
- Let the AI drive. An autonomous crawler navigates the app on its own while the specialist agents test everything it touches.
- Drive it yourself. Browse the app manually through the browser extension, a separate identity per tab, and the agents analyze and test every request you make, live, as you click.
Because both drivers share the same pipeline, you mix them in a single session. Walk the gnarly multi-step checkout or the SSO handshake by hand, let the AI sweep the boring breadth, and get one unified, de-duplicated set of proven findings. That’s what “augmented” means here: the AI covers the basics and the breadth so you can spend your attention on the creative, high-value parts.
Work alongside the agents
CyberStrike gives you a human’s seat at the table the whole time, not just at the end.
A real repeater. The same send engine the agents use, http_replay, is yours to drive. Take any captured request and:
- swap credentials: strip the session auth, drop in another role’s, and watch for cross-user access (IDOR/BOLA) in one call;
- compare: fire a baseline and an exploit side by side and get a structured diff of status, body, and timing;
- sweep: vary one parameter across a list of values;
- craft raw: byte-exact requests for smuggling and malformed-input work.
Every mutation can run through an encoder chain (URL, double-URL, base64, hex, unicode, and more), and the tool returns facts, not verdicts: status, reflection, error signatures, and a copy-paste curl.
Take the wheel anytime. Pause the ingest queue (/qpause) to stop the machine mid-run, poke at something by hand, then resume (/qresume). Launch or stop the crawler (/hackbrowser), browse findings (/vulnerabilities), check coverage (/methodology), compile a report (/report), all from the prompt.
You have the final say on findings. Nothing is promoted behind your back. Findings land as drafts; an agent can only mark one verified if it attached replayable evidence, otherwise it stays a draft for a human to judge. Rejecting a finding requires a reason. The vulnerabilities view is your review surface: accept, reject, or reopen.
Bring your smart tools
The agents are only as good as what’s behind them, so CyberStrike lets you wire in the toolchain you already trust.
Query the traffic corpus. Every request and response flows into one engine that you (and the agents) can query: pull every object reached under more than one role as an IDOR candidate, find where a leaked value flows, list endpoints discovered but never tested. You start from evidence instead of hunting blind.
Run the real binaries, in a sandbox. Through Bolt, a containerized tool server, agents (and you) get the industry-standard kit (nmap, nuclei, ffuf, httpx, subfinder, sqlmap, amass, katana, and more) running in an isolated Docker container with signed access, no local installs. Pair it once, then pick which servers and tools are live from the /bolt menu.
Plug in intelligence. CyberStrike ships with a set of security MCP servers (CVE and vulnerability intel, OSINT and exposed-asset lookups, multi-cloud config auditing, and more), off by default. Flip on the ones you want with a line of config, or point it at your own MCP server. You decide what CyberStrike is allowed to reach.
Make it yours
This is where teams get the most value. Almost everything that matters is configuration, in a cyberstrike.json (or a .cyberstrike/ folder) that lives with the project, and in an enterprise, a managed config that always wins.
Your models. Bring your own provider and key (apiKey, baseURL, custom model metadata). Set a primary and a cheaper small_model, or assign a specific model per agent: run your heavy reasoning on one model and routine triage on another. Allow-list or deny-list providers org-wide.
Your agents. Define your own agent as a Markdown file in .cyberstrike/agent/: frontmatter sets its model, tools, permissions, and step budget; the body is its prompt. You can also override any built-in: change its model, retune its prompt, tighten its permissions, cap its steps, or disable it entirely. Want a specialist that only ever tests one thing a particular way? Write it once, commit it, and the whole team gets it.
Your playbooks (skills). A skill is a SKILL.md: a reusable testing playbook the agents invoke by name. CyberStrike ships thousands of them (CIS benchmarks, NIST, MITRE ATT&CK, the full OWASP WSTG, plus curated attack skills for SSRF, JWT, GraphQL, AD/Kerberos, cloud and K8s post-exploitation, LLM security, and more), and you author your own, point skills.paths at a folder or a URL, disable the ones you don’t want, and sign them for integrity.
Your attack chains. The escalation hunter works from a catalog of known chains (SSRF into cloud-metadata theft, IDOR plus predictable IDs into mass exfiltration, open redirect plus OAuth into account takeover). Drop your own chain definitions into a folder (CYBERSTRIKE_ESCALATION_CATALOG_DIR) as JSON: each pattern names the primitives it requires and the impact it implies, and the hunter will pursue them too.
Your roles and scope. Access-control testing is only as good as the identities you give it. Define roles with privilege levels (guest to admin), capture a real session per role (one browser container each), and CyberStrike will replay across them to prove who can reach what. Set scope explicitly so no tool ever sends outside the hosts you authorized.
Your rules of engagement. Per-agent tool permissions, global permission rules, extra instruction files (AGENTS.md-style, concatenated into every run), and custom slash commands all live in config: version-controlled, reviewable, and shared across the team.
For teams
CyberStrike scales from one tester’s laptop to a program:
- Shared, reviewable configuration. Models, agents, skills, scope, and permissions are files in the repo: a team’s testing standard becomes code everyone inherits, and an org can enforce a managed config that overrides local ones.
- Human-in-the-loop by default. Drafts, evidence-gated promotion, and reject-with-reason mean the AI proposes and your team disposes.
- Reports on your terms. Generate a Markdown report with the sections you want (findings, coverage, methodology, attack surface, chains, timeline) with fill-in spots for your executive summary and remediation narrative.
- Measurable coverage. Track progress against OWASP WSTG and Top-10 and CIS-aligned benchmarks, scoped to the target, so you can show exactly what was tested.
The point
CyberStrike doesn’t ask you to trust a black box or hand over the engagement. The AI handles the breadth and the basics; the repeater, the queue controls, and the triage gate keep you in command; the tool sandbox and MCP integrations bring your own kit; and the config layer lets you define the agents, models, playbooks, chains, roles, and rules that make it your process.
Autonomous when you want it. Augmented when it matters. Yours either way.
Try it at cyberstrike.io, or reach the team at [email protected]. Capabilities evolve; some integrations described are opt-in or on the roadmap.
