Skip to content
Back to search

violin

Supervised, Hermes-native penetration testing profile with 35 routed playbooks, guarded target execution, persistent engagement state, evidence-backed findings, and release-gated reporting.

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/Strategic-Automation/violin 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/Strategic-Automation/violin'

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/strategic-automation--violin/badge.svg)](/listings/strategic-automation--violin)

HTML

<a href="/listings/strategic-automation--violin"><img src="/api/listings/strategic-automation--violin/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.

Install the profile

hermes profile install https://github.com/Strategic-Automation/violin
hermes -p violin

Then start with an authorized target and let Violin collect the scope before any target interaction:

Run an authorized penetration test against example.com.

Requirements

- [Hermes Agent](https://hermes-agent.nousresearch.com/) 0.18.0 or newer - Python 3.11 and `uv` for local development - Kali Linux or Parrot OS for the expected security-tool environment - Written authorization and an approved scope

Violin does not select a model or provider. Configure those in Hermes. For a capable default, use **Qwen3.8 27B** locally or **DeepSeek V4 Flash** through a hosted provider.

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 · 348 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. <p align="center">
  2. <img src="assets/logo.png" alt="Violin" width="256"/>
  3. </p>
  4. <h1 align="center">Violin ☤ — Supervised Agentic Hermes Pentest Profile</h1>
  5. <p align="center">
  6. <a href="https://github.com/Strategic-Automation/violin"><img src="https://img.shields.io/badge/Status-Release%20Ready-2ea44f?style=for-the-badge" alt="Release Ready"></a>
  7. <a href="https://github.com/Strategic-Automation/violin/blob/master/LICENSE"><img src="https://img.shields.io/badge/License-MIT-blue?style=for-the-badge" alt="License: MIT"></a>
  8. <a href="https://hermes-agent.nousresearch.com/"><img src="https://img.shields.io/badge/Hermes-%3E%3D0.21.5-FFD700?style=for-the-badge" alt="Hermes >=0.21.5"></a>
  9. <a href="https://www.kali.org/"><img src="https://img.shields.io/badge/Kali%20Linux-557C94?style=for-the-badge&logo=kali-linux&logoColor=white" alt="Kali Linux"></a>
  10. <a href="https://www.parrotsec.org/"><img src="https://img.shields.io/badge/Parrot%20OS-2E8B57?style=for-the-badge" alt="Parrot OS"></a>
  11. <a href="https://strategic-automation.github.io/violin/"><img src="https://img.shields.io/badge/Site-Landing%20page-FF3B4A?style=for-the-badge" alt="Landing page"></a>
  12. <a href="https://github.com/Strategic-Automation/violin/stargazers"><img src="https://img.shields.io/github/stars/Strategic-Automation/violin?style=for-the-badge&color=FFD166" alt="GitHub stars"></a>
  13. </p>
  14. <p align="center">
  15. <b>35 playbooks · 19 references · 14 templates · required execution guard · Hermes-native</b>
  16. </p>
  17. Violin is a **Hermes-native agentic pentest profile** for supervised, authorised penetration tests — from reconnaissance through safe exploit validation to reporting. It uses Hermes' built-in toolsets, seven routed skills, and the required `violin_guard` plugin at the target-execution boundary. The standalone CLI supports release checks, diagnostics, and administrative recovery; target commands run through the plugin. Violin adds no profile-specific credentials and inherits the provider and tool backends already configured in Hermes.
  18. <p align="center">
  19. <a href="#quick-start">Quick start</a> ·
  20. <a href="#engagement-lifecycle">Workflow</a> ·
  21. <a href="#guard-tools">Guard tools</a> ·
  22. <a href="#benchmarks">Benchmarks</a> ·
  23. <a href="https://strategic-automation.github.io/violin/">Landing page</a> ·
  24. <a href="https://github.com/Strategic-Automation/violin/discussions">Discussions</a> ·
  25. <a href="#development">Development</a>
  26. </p>
  27. <p align="center">
  28. <strong>Following Violin?</strong>
  29. <a href="https://github.com/Strategic-Automation/violin/stargazers">Star the repository</a>
  30. to keep it easy to find and help other security engineers discover supervised agentic pentesting.
  31. </p>
  32. ### Community discovery
  33. Violin is listed in community-curated collections including
  34. [awesome-ai-security](https://github.com/gmh5225/awesome-ai-security),
  35. [awesome-hermes-skills](https://github.com/ZeroPointRepo/awesome-hermes-skills),
  36. [awesome-hermes-agent](https://github.com/Anil-matcha/awesome-hermes-agent), and
  37. [awesome-infosec](https://github.com/onlurking/awesome-infosec).
  38. Third-party coverage:
  39. [Starlog technical analysis](https://starlog.is/articles/cybersecurity/strategic-automation-violin) and
  40. [“Violin: Supervised Agentic Penetration Testing Profile for Hermes Agent”](https://hamradio.my/violin-supervised-agentic-pentest-profile-hermes/).
  41. For independent evaluation, use the
  42. [reviewer kit](https://strategic-automation.github.io/violin/review.html), which
  43. collects the benchmark path, known limits, review context, and a factual
  44. comparison with autonomous pentest-agent designs.
  45. ---
  46. <table>
  47. <tr><td width="240"><strong>Guarded target execution</strong></td><td>Scope, phase, PTT, skill, hypothesis, history, and synchronization checks run before a target command starts.</td></tr>
  48. <tr><td><strong>Persistent engagement state</strong></td><td>PTT tasks, hypotheses, command history, checkpoints, evidence, and reports survive context compression.</td></tr>
  49. <tr><td><strong>Evidence-backed findings</strong></td><td>A typed submission binds each validated finding to authenticated execution receipts.</td></tr>
  50. <tr><td><strong>Routed methodology</strong></td><td>A pentest orchestrator selects focused web, identity, API, business-logic, LLM-security, and misconfiguration playbooks.</td></tr>
  51. <tr><td><strong>Bounded execution</strong></td><td>Single commands, command bursts, background processes, batch review, heartbeat checks, and cancellation share one state model.</td></tr>
  52. <tr><td><strong>Verifiable releases</strong></td><td>Plugin registration, schemas, skill snapshots, documentation contracts, lint, formatting, and the full test suite are release-gated.</td></tr>
  53. </table>
  54. ## Quick start
  55. ### Install the profile
  56. ```bash
  57. hermes profile install https://github.com/Strategic-Automation/violin
  58. hermes -p violin plugins disable violin_guard
  59. hermes -p violin plugins enable violin_guard --no-allow-tool-override
  60. hermes -p violin
  61. ```
  62. Guard dependencies are declared in `plugins/violin_guard/plugin.yaml`. The
  63. plugin name, directory, and enabled configuration all use `violin_guard`, so
  64. Hermes can resolve its dependencies without a directory workaround. Installing
  65. dependencies into the development `.venv` does not install them into Hermes.
  66. The disable/enable cycle above forces dependency admission even when the profile
  67. configuration already enables the plugin. Verify registration after installation:
  68. ```bash
  69. hermes -p violin plugins doctor ~/.hermes/profiles/violin/plugins/violin_guard --ci
  70. hermes -p violin tools list
  71. ```
  72. Plugin Doctor should report 12 tools and 5 hooks, and `violin_guard` should appear
  73. as an enabled toolset. Restart Hermes after installation before starting an
  74. engagement. Reinstall the profile to migrate an older `violin-guard` installation.
  75. Then start with an authorized target and let Violin collect the scope before
  76. any target interaction:
  77. ```text
  78. Run an authorized penetration test against example.com.
  79. ```
  80. ### Requirements
  81. - [Hermes Agent](https://hermes-agent.nousresearch.com/) 0.21.5 or newer (container pins the `v2026.9.24` release commit)
  82. - Python 3.11 and `uv` for local development
  83. - Kali Linux or Parrot OS for the expected security-tool environment
  84. - Written authorization and an approved scope
  85. Violin does not select a model or provider. Configure those in Hermes. For a
  86. capable default, use **Qwen3.8 27B** locally or **DeepSeek V4 Flash** through a
  87. hosted provider.
  88. ## Engagement lifecycle
  89. ```mermaid
  90. flowchart LR
  91. S[Scope] --> R[Recon]
  92. R --> V[Vulnerability research]
  93. V --> E[Exploit validation]
  94. E --> P[Reporting]
  95. P --> X[Retrospective]
  96. G[Violin Guard] -. validates .-> R
  97. G -. validates .-> V
  98. G -. validates .-> E
  99. ```
  100. 1. Initialize the engagement and approve `scope/scope.yaml`.
  101. 2. Select one active PTT task and its routed skill with
  102. `violin_record_ptt`.
  103. 3. Run target commands with `violin_exec` or `violin_exec_burst`.
  104. 4. Update hypotheses as evidence changes their status.
  105. 5. Review each bounded command batch with `violin_review_batch`.
  106. 6. Submit validated findings and generate the final report.
  107. 7. Complete the retrospective.
  108. The complete phase model is:
  109. ```text
  110. SCOPING → RECON → VULN_RESEARCH → EXPLOITATION
  111. → POST_EXPLOITATION / PRIVESC / FLAGS
  112. → REPORTING → RETROSPECTIVE
  113. ```
  114. Starting work in a new phase requires a PTT task under that phase. Existing
  115. tasks are not moved between phase sections.
  116. ## Guard tools
  117. The plugin registers twelve Hermes tools from one typed registry:
  118. | Tool | Purpose |
  119. |---|---|
  120. | `violin_record_ptt` | Create, start, refresh, close, or cancel a PTT task |
  121. | `violin_record_hypothesis` | Create or update a scoped hypothesis |
  122. | `violin_submit_finding` | Submit a validated finding bound to its signed execution receipts |
  123. | `violin_exec` | Execute one guarded command |
  124. | `violin_exec_burst` | Execute a bounded command file |
  125. | `violin_exec_status` | Read background execution status |
  126. | `violin_exec_cancel` | Cancel tracked background execution |
  127. | `violin_review_batch` | Review a completed batch and settle state |
  128. | `violin_rebind_pending_batch` | Rebind a pending batch after confirmation |
  129. | `violin_heartbeat_done` | Clear a completed heartbeat review |
  130. | `violin_target` | Resolve the approved assessment target |
  131. | `violin_status` | Explain current tasks, skills, and blockers |
  132. `violin_exec` is the generic target-command boundary. There are no
  133. tool-specific execution adapters or binary allowlists. Installed
  134. non-interactive tools may run only after the engagement gates pass.
  135. The raw-terminal hook is a best-effort safety net, not network containment.
  136. Use `terminal` only for host-local preparation and administration.
  137. ## Safety model
  138. ```mermaid
  139. flowchart LR
  140. A[Written authorization] --> B[Approved scope]
  141. B --> C[Active phase task]
  142. C --> D[Skill and hypothesis gates]
  143. D --> E[Guarded execution]
  144. E --> F[Evidence receipt]
  145. F --> G[Batch review]
  146. ```
  147. - No target interaction before scope approval and bootstrap validation.
  148. - No raw shell execution for target commands.
  149. - No destructive, disruptive, credential, persistence, stealth, or
  150. third-party action without explicit written authorization.
  151. - Raw evidence stays under `$ENG_DIR/evidence/<phase>/`.
  152. - Secrets, dumps, and proof output stay out of `$ENG_DIR/state/`.
  153. - Context compression resumes from engagement files in the current Hermes
  154. conversation.
  155. The detailed policy is
  156. [`skills/pentest/references/standards.md`](skills/pentest/references/standards.md).
  157. ## Engagement state
  158. `init-engagement` creates the canonical working structure:
  159. ```text
  160. $ENG_DIR/
  161. ├── scope/
  162. │ └── scope.yaml
  163. ├── state/
  164. │ ├── ptt.md
  165. │ ├── history.md
  166. │ └── checkpoint.json
  167. ├── hypotheses.md
  168. ├── evidence/
  169. ├── reporting/
  170. └── retrospective/
  171. ```
  172. ### Upgrading from Violin 3.3
  173. Violin 4.0 stores executor state in `state/runtime.json` and does not migrate
  174. the 3.3 `sync.json`, `counts.json`, or `heartbeat.json` files. Start a new
  175. engagement in a new directory; keep the 3.3 directory as a historical record.
  176. Reusing its directory leaves the legacy state files in place, so Violin 4.0
  177. will reject it.
  178. ### Skill delivery
  179. Skills are loaded on demand. The first `violin_record_ptt` call for a routed
  180. skill may return `skill_prepared` without changing the PTT. After Hermes
  181. delivers the skill content, repeat the transition to bind the receipt and apply
  182. the task change. `violin_status` reports the exact recovery action.
  183. Marker files such as `.skill-loaded-*` do not prove skill delivery.
  184. ## Routed skills
  185. | Skill | Coverage |
  186. |---|---|
  187. | `pentest` | Scope, lifecycle, recon, exploitation, reporting, closeout |
  188. | `web-app` | Injection, SSRF, traversal, deserialization, client-side flaws |
  189. | `identity-auth` | Authentication, authorization, IDOR, JWT, CSRF, cryptography |
  190. | `api-testing` | REST, SOAP, GraphQL, WebSocket |
  191. | `business-logic` | Workflow, pricing, coupon, quota, referral, race conditions |
  192. | `llm-security` | Prompt injection, MCP, JSON-RPC |
  193. | `misconfig` | Deployment, error handling, observability, obscurity |
  194. The orchestrator loads only the phase material and specialist playbook needed
  195. for the current task.
  196. ## Administrative CLI
  197. The CLI does not replace guarded target execution.
  198. ```bash
  199. python scripts/violin_guard.py --help
  200. python scripts/violin_guard.py init-engagement engagements/example --host example.com
  201. python scripts/violin_guard.py check-bootstrap --eng-dir engagements/example
  202. python scripts/violin_guard.py status --eng-dir engagements/example
  203. python scripts/violin_guard.py generate-closeout --eng-dir engagements/example
  204. python scripts/violin_guard.py check-release
  205. ```
  206. `check-command` exposes admission checks for diagnostics and does not execute
  207. the supplied command.
  208. ## Architecture
  209. ```text
  210. plugins/violin_guard/
  211. ├── core/
  212. │ ├── commands/ shell parsing, targets, HTTP proof
  213. │ ├── engagement/ state, PTT, phases, hypotheses, bootstrap
  214. │ ├── evidence/ findings, history, receipts, redaction
  215. │ └── skills/ skill policy and receipts
  216. ├── gates/ command, scope, hypothesis, terminal policies
  217. ├── engine/ execution, runtime backend, code audit, release checks
  218. ├── handlers/ public Hermes tool handlers
  219. ├── hooks.py Hermes lifecycle hooks
  220. └── registry.py registered tool definitions
  221. skills/ orchestrator, routed skills, playbooks, references
  222. benchmark/ runner, scorer, proof checks, calibration fixtures
  223. scripts/ administrative CLI and platform smoke tests
  224. tests/ runtime, integration, documentation, release tests
  225. ```
  226. ## Benchmarks
  227. The repository includes the Escape Duck Store definition plus known-good and
  228. known-bad scorer fixtures. Calibration proves that the scorer handles those
  229. fixtures; it does not establish live-agent recall, workflow completion, or
  230. report quality.
  231. ```bash
  232. uv run python -m benchmark.score --calibrate known-good
  233. uv run python -m benchmark.score --calibrate known-bad
  234. uv run python -m benchmark.run \
  235. --target http://localhost:<published-port> \
  236. --provider <provider> \
  237. --api-base <openai-compatible-base-url> \
  238. --model <model-id> \
  239. --target-isolation-id escape-duck-store-2026-04:<image-digest-or-reset-id>
  240. ```
  241. Read the [benchmark methodology](docs/BENCHMARKS.md) before publishing a score.
  242. It defines the proof, reproducibility, private evaluation, and disclosure
  243. requirements for a credible result.
  244. ## Development
  245. ```bash
  246. uv sync --dev
  247. uv run pytest
  248. uv run ruff check .
  249. uv run ruff format --check .
  250. uv run python scripts/violin_guard.py check-release
  251. ```
  252. The release gate checks version surfaces, isolated plugin import, registered
  253. tools, generated schemas, skill snapshots, documentation contracts, Ruff, and
  254. the full test suite.
  255. Platform smoke tests:
  256. - `scripts/smoke-test.sh` — Linux and Kali/Parrot release smoke
  257. - `scripts/smoke-test.ps1` — Windows bootstrap, scope, and target-resolution
  258. smoke; skill delivery and target execution require Hermes
  259. See [CONTRIBUTING.md](CONTRIBUTING.md) for contribution rules and
  260. [SECURITY.md](SECURITY.md) for private vulnerability reporting.
  261. ## Responsible use
  262. Violin is for authorized security assessment. Operators are responsible for
  263. scope, approvals, target ownership, data handling, and local law.
  264. ## Support Violin
  265. Violin is an open-source project maintained by Strategic Automation Ltd.
  266. If Violin is useful to you or your organisation, you can
  267. [sponsor its continued development](https://github.com/sponsors/Strategic-Automation).
  268. Sponsorship supports continued development, testing, documentation,
  269. compatibility work, and releases.
  270. Violin remains available under the MIT licence. Sponsorship does not include
  271. guaranteed support, feature priority, or influence over security policy.
  272. ## License
  273. MIT — see [LICENSE](LICENSE).

Ratings and comments

Sign in to rate this skill.

Sign in

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