Skip to content
Back to search

super-hermes

Skills that teach Hermes Agent to write its own analytical prompts

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/cranot--super-hermes/badge.svg)](/listings/cranot--super-hermes)

HTML

<a href="/listings/cranot--super-hermes"><img src="/api/listings/cranot--super-hermes/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.

Requires [Hermes Agent](https://github.com/NousResearch/hermes-agent). Works with any model Hermes supports.

Skills Hub (one command, no clone)

hermes skills install Cranot/super-hermes/skills/prism-scan

That installs `prism-scan` **and** the 7 proven prisms, which ship as its reference files. Add the others the same way:

hermes skills install Cranot/super-hermes/skills/prism-full
hermes skills install Cranot/super-hermes/skills/prism-3way
hermes skills install Cranot/super-hermes/skills/prism-discover
hermes skills install Cranot/super-hermes/skills/prism-reflect

To make all five searchable from inside Hermes, add the repo as a tap once:

hermes skills tap add Cranot/super-hermes
hermes skills search prism

Installed skills take effect in new sessions — use `/reset`, or pass `--now`, to pick them up in the current one.

Manual (git clone)

git clone https://github.com/Cranot/super-hermes.git
cd super-hermes
bash install.sh

On Windows: `powershell -ExecutionPolicy Bypass -File install.ps1`

Or by hand:

cp -r skills/* ~/.hermes/skills/
cp skills/prism-scan/references/*.md ~/.hermes/prisms/    # proven analytical lenses

Try it now (no Hermes needed)

cat your_code.py | claude -p --system-prompt-file skills/prism-scan/references/l12.md --model sonnet --tools ""
# Or test on a real open-source file:
curl -s https://raw.githubusercontent.com/encode/starlette/master/starlette/routing.py | claude -p --system-prompt-file skills/prism-scan/references/l12.md --model sonnet --tools ""

You should see: a **Generated Lens** (custom analytical instructions), a **findings table** (bugs with line numbers and severity), and a **conservation law** (structural trade-off that can't be engineered away). If you see a generic code review instead, the prism didn't load — check the file path.

The 7 prisms work with any tool that supports system prompts — Claude CLI, Anthropic API, Cursor, or any LLM.

Try it with Hermes

hermes> /prism-scan analyze examples/circuit_breaker.py

Real output from Hermes Agent (truncated):

⚡ Loading skill: prism-scan

  ┊ 🔎 grep      .prism-history.md  0.7s

No prior constraint history. Analyzing fresh.

## Generated Lens
"Extract the temporal invariant in state transitions. Map every state path
from CLOSED → OPEN → HALF_OPEN → CLOSED. For each transition, identify:
(1) what determines the transition happens, (2) what could block it,
(3) whether the state is mutated inside or outside the critical section.
Build a second circuit breaker that inverts the lock placement..."

## Conservation Law
"Decentralized lock placement in a state machine with time-based transitions
creates a fundamental trade-off: either (1) atomicity is sacrificed, or
(2) lock contention increases because read operations must hold the lock."

CONSTRAINT NOTE: This analysis maximized temporal correctness and lock
placement asymmetry. It did not examine: listener performance/blocking
impact under load, integer overflow on failure_count.

*Real output from Hermes Agent (Claude Haiku 4.5 via OpenRouter) on `examples/circuit_breaker.py`. The underlying prism methodology is validated on 6 real open-source codebases in the [research repo](https://github.com/Cranot/agi-in-md). See `examples/` for all skill outputs from a complete Hermes session.*

---

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 · 265 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Super Hermes
  2. **The agent that knows what it can't do.**
  3. Super Hermes teaches Hermes Agent to write its own thinking instructions, report what it found AND what it missed, and grow smarter with every analysis.
  4. **Vanilla Hermes:** "The session handling is tightly coupled. Consider decoupling."
  5. *Names a pattern. Tells you what to change.*
  6. **Super Hermes:** "Session state is non-monotonic. No append-only, composable, or lazy architecture can manage it without sacrificing consistency or isolation. **This is a structural impossibility, not a code flaw.**"
  7. *Derives WHY the code must be this way. Tells you what you can't change — and what to do instead.*
  8. **Plus a constraint report:** "This analysis maximized structural depth. It did not examine temporal degradation or security surfaces. For those: `/prism-reflect`"
  9. The difference isn't intelligence — it's cognitive structure:
  10. | | Vanilla (same model, same code) | With prism |
  11. |---|---|---|
  12. | Output | 339 words | 1,485 words |
  13. | Finds bugs | 7 (surface checklist) | 11 (with line refs, severity, structural classification) |
  14. | Finds structural trade-offs | No | Yes — conservation law derived |
  15. | Reports blind spots | No | Yes — constraint footer |
  16. | Cost | ~$0.05 | ~$0.05 (same) |
  17. *Validated on real open-source codebases: Starlette `routing.py`, Click `core.py`, Tenacity `retry.py`. Those files have since grown — as of 2026-07 upstream `master` they are 747, 3,792 and 293 lines; the scoring runs used the 2026-03 revisions. Full outputs in `examples/`.*
  18. *Every bug in the examples has exact line numbers you can verify. The race condition in `circuit_breaker.py` (impure `state` property writing `_state` without lock) is independently reproducible — inspect the code yourself.*
  19. ---
  20. ## What It Does
  21. Before any complex task, Super Hermes **writes its own thinking instructions** — a cognitive prism tailored to the specific problem. Different problems get different prisms. Then it executes the prism and reports both what it found AND what it couldn't see.
  22. **Example:** Given a circuit breaker implementation, the agent generated:
  23. > *"Identify every temporal assumption in this artifact's state transitions. Simulate concurrent execution that violates each. Construct three alternatives inverting one temporal assumption each. Trace which creates silent statistical failures rather than immediate exceptions."*
  24. The agent wrote that. Then it executed it and found a concurrency trilemma — a structural property that persists across ALL possible implementations.
  25. ---
  26. ## Skills
  27. | Skill | What it does | Calls |
  28. |---|---|---|
  29. | `/prism-scan` | Generate optimal lens for this artifact, execute it, report findings + constraints. Add "focusing on X" to direct the lens. | 1 |
  30. | `/prism-full` | Multi-pass pipeline with mandatory adversarial self-correction — later passes attack earlier findings | 1 (multi-pass within single response) |
  31. | `/prism-3way` | WHERE/WHEN/WHY — three orthogonal operations + cross-operation synthesis. Works on any domain (code, business, strategy, text). | 1 |
  32. | `/prism-discover` | Map every possible analysis domain for an artifact | 1 |
  33. | `/prism-reflect` | Self-aware analysis — structural findings + meta-analysis of what the analysis concealed + constraint transparency report | 2-3 |
  34. ### Proven Prisms (included in `skills/prism-scan/references/`)
  35. 7 battle-tested analytical lenses from the research. They ship inside the `prism-scan` skill so a one-command hub install delivers them too, and both installers also copy them to `~/.hermes/prisms/`. Use directly with Hermes or any tool that supports system prompts:
  36. | Prism | What it finds | Validated score |
  37. |-------|--------------|-----------------|
  38. | `error_resilience.md` | Corruption cascade chains — silent exits, deferred failures, state corruption | 10.0/10 |
  39. | `l12.md` | Conservation laws (structural trade-offs that can't be engineered away — like CAP theorem for your code) + meta-laws + concrete bugs | 9.8/10 |
  40. | `optimize.md` | Critical path tracing — safe fixes (reduce work) vs unsafe (skip work) + conservation law | 9.5/10 |
  41. | `identity.md` | What code claims to be vs what it actually does | 9.5/10 |
  42. | `deep_scan.md` | Information destruction, laundering, silent transformation | 9.0/10 |
  43. | `claim.md` | Assumption inversions — what if accepted truths are false? | 9.0/10 |
  44. | `simulation.md` | Temporal prediction — what breaks over time | 9.0/10 |
  45. *Scores are from AI-evaluated depth across real open-source codebases (Starlette, Click, Tenacity, Flask, Rich, Requests). Raw outputs available in the [research repo](https://github.com/Cranot/agi-in-md).*
  46. These prisms work independently of the skills — use them as system prompts with `claude -p --system-prompt-file skills/prism-scan/references/l12.md`, with the Anthropic API, or with any LLM tool. Inside Hermes, load one on demand with `skill_view("prism-scan", "references/l12.md")`. The `/prism-scan` skill generates custom lenses dynamically; these proven prisms are pre-built alternatives with validated quality.
  47. ### /prism-3way — Multi-Angle Analysis
  48. Attacks the problem from three orthogonal directions in a single run:
  49. - **WHERE** (archaeology): dig through structural layers — what's visible, what's hidden, what's between
  50. - **WHEN** (simulation): run forward through time — what breaks, calcifies, gets lost
  51. - **WHY** (impossibility): prove which desirable properties can't coexist
  52. Then a **synthesis** cross-references all three — agreements are structural certainties, disagreements are where the real insight hides. Works on code, business plans, strategy docs, research — any domain.
  53. ### /prism-reflect — The Differentiator
  54. Most agents tell you what they found. `/prism-reflect` also tells you what it **missed**:
  55. ```
  56. CONSTRAINT REPORT
  57. ═══════════════════════════════════════════════════
  58. This analysis used: Structural depth pipeline
  59. Maximized: Conservation laws, bug classification, ownership chains
  60. Sacrificed: Temporal prediction, security analysis, user adaptation
  61. Recommendations:
  62. - For how this code degrades over time: /prism-scan with temporal focus
  63. - For security attack surfaces: /prism-scan with security focus
  64. - For full multi-angle coverage: /prism-full
  65. Conservation law of this analysis:
  66. Depth × Breadth = Constant. I went deep on structure.
  67. I went shallow on everything else. Now you know.
  68. ═══════════════════════════════════════════════════
  69. ```
  70. **Why this matters:** You can't trust an agent that doesn't know its limits. Every analysis has blind spots. `/prism-reflect` makes them visible so you can fill the gaps.
  71. ---
  72. ## Install
  73. Requires [Hermes Agent](https://github.com/NousResearch/hermes-agent). Works with any model Hermes supports.
  74. ### Skills Hub (one command, no clone)
  75. ```bash
  76. hermes skills install Cranot/super-hermes/skills/prism-scan
  77. ```
  78. That installs `prism-scan` **and** the 7 proven prisms, which ship as its reference files. Add the others the same way:
  79. ```bash
  80. hermes skills install Cranot/super-hermes/skills/prism-full
  81. hermes skills install Cranot/super-hermes/skills/prism-3way
  82. hermes skills install Cranot/super-hermes/skills/prism-discover
  83. hermes skills install Cranot/super-hermes/skills/prism-reflect
  84. ```
  85. To make all five searchable from inside Hermes, add the repo as a tap once:
  86. ```bash
  87. hermes skills tap add Cranot/super-hermes
  88. hermes skills search prism
  89. ```
  90. Installed skills take effect in new sessions — use `/reset`, or pass `--now`, to pick them up in the current one.
  91. ### Manual (git clone)
  92. ```bash
  93. git clone https://github.com/Cranot/super-hermes.git
  94. cd super-hermes
  95. bash install.sh
  96. ```
  97. On Windows: `powershell -ExecutionPolicy Bypass -File install.ps1`
  98. Or by hand:
  99. ```bash
  100. cp -r skills/* ~/.hermes/skills/
  101. cp skills/prism-scan/references/*.md ~/.hermes/prisms/ # proven analytical lenses
  102. ```
  103. ### Try it now (no Hermes needed)
  104. ```bash
  105. cat your_code.py | claude -p --system-prompt-file skills/prism-scan/references/l12.md --model sonnet --tools ""
  106. ```
  107. ```bash
  108. # Or test on a real open-source file:
  109. curl -s https://raw.githubusercontent.com/encode/starlette/master/starlette/routing.py | claude -p --system-prompt-file skills/prism-scan/references/l12.md --model sonnet --tools ""
  110. ```
  111. You should see: a **Generated Lens** (custom analytical instructions), a **findings table** (bugs with line numbers and severity), and a **conservation law** (structural trade-off that can't be engineered away). If you see a generic code review instead, the prism didn't load — check the file path.
  112. The 7 prisms work with any tool that supports system prompts — Claude CLI, Anthropic API, Cursor, or any LLM.
  113. ### Try it with Hermes
  114. ```
  115. hermes> /prism-scan analyze examples/circuit_breaker.py
  116. ```
  117. Real output from Hermes Agent (truncated):
  118. ```
  119. ⚡ Loading skill: prism-scan
  120. ┊ 🔎 grep .prism-history.md 0.7s
  121. No prior constraint history. Analyzing fresh.
  122. ## Generated Lens
  123. "Extract the temporal invariant in state transitions. Map every state path
  124. from CLOSED → OPEN → HALF_OPEN → CLOSED. For each transition, identify:
  125. (1) what determines the transition happens, (2) what could block it,
  126. (3) whether the state is mutated inside or outside the critical section.
  127. Build a second circuit breaker that inverts the lock placement..."
  128. ## Conservation Law
  129. "Decentralized lock placement in a state machine with time-based transitions
  130. creates a fundamental trade-off: either (1) atomicity is sacrificed, or
  131. (2) lock contention increases because read operations must hold the lock."
  132. CONSTRAINT NOTE: This analysis maximized temporal correctness and lock
  133. placement asymmetry. It did not examine: listener performance/blocking
  134. impact under load, integer overflow on failure_count.
  135. ```
  136. *Real output from Hermes Agent (Claude Haiku 4.5 via OpenRouter) on `examples/circuit_breaker.py`. The underlying prism methodology is validated on 6 real open-source codebases in the [research repo](https://github.com/Cranot/agi-in-md). See `examples/` for all skill outputs from a complete Hermes session.*
  137. ---
  138. ## How It Works Under the Hood
  139. A prism is a structured analytical program — not "analyze this code" but a step-by-step construction protocol. Here's what `skills/prism-scan/references/l12.md` (326 words) tells the model to do:
  140. > *Make a falsifiable claim about the deepest problem. Three experts attack it — one defends, one attacks, one probes assumptions. Engineer an improvement that deepens the concealment. Name what the improvement reveals. Engineer a second improvement. Find the structural invariant that persists through every improvement. Invert it. The conservation law between original and inverted impossibilities is the finding. Apply the diagnostic to the law itself. The meta-law is the deeper finding. Collect every concrete bug.*
  141. This is a **program** the model executes. Different code → different construction paths → different findings. The model doesn't "think harder" — it follows a different analytical procedure than vanilla prompting.
  142. The `/prism-scan` skill takes this further: instead of using a fixed prism, it generates a **custom** one for each artifact. The model reads your code, decides what analytical approach fits, writes the instructions, then follows them.
  143. Unlike chain-of-thought (show your reasoning) or tree-of-thought (explore branches), prisms force **construction** — build something, watch it fail, derive what survives. This produces findings that enumeration cannot reach, because the construction reveals properties that were invisible before the attempt.
  144. Based on the [cognitive compression taxonomy](https://github.com/Cranot/agi-in-md): 1,000+ experiments across 40 research rounds, 204+ empirical principles. Validated inside Hermes Agent (Gemini 2.5 Flash). Also proven on Claude Sonnet, Hermes 3 (Llama 405B), and Llama 3.1 70B.
  145. ---
  146. ## "The Agent That Grows With You"
  147. Other agents grow by accumulating data about you. Super Hermes grows by accumulating **thinking strategies** — learning WHICH analytical approach works for WHICH problem.
  148. **What's built and working:**
  149. - **7 proven prisms** ship in `skills/prism-scan/references/` — battle-tested analytical lenses from 1,000+ experiments, ready to use immediately.
  150. - **The cooker** generates NEW prisms on the fly — every problem gets a custom-tailored analytical approach. No two analyses are identical.
  151. - **Constraint history** — `/prism-reflect` saves its constraint report to `.prism-history.md` in your project. The next time `/prism-scan` runs on any file in the same project, it reads past constraint reports and adjusts its lens to cover previously missed angles. The agent literally learns from its own blind spots.
  152. - **Self-governance** — an agent that reports what it can't see enables informed decisions about when to go deeper vs when to accept the analysis.
  153. **The growth loop:**
  154. ```
  155. /prism-scan code.py → generates lens, produces analysis + constraint footer
  156. /prism-reflect code.py → deeper analysis + saves constraint report to .prism-history.md
  157. /prism-scan other_file.py → reads .prism-history.md, adjusts lens to cover past gaps
  158. ↑ THIS is "grows with you" — the agent gets smarter per project
  159. ```
  160. *The growth loop is demonstrated in [`examples/growth-demo.md`](examples/growth-demo.md) — same code, same skill, genuinely different analysis because the agent learned from its previous blind spots. See [Limitations](#limitations) for caveats.*
  161. ---
  162. ## Limitations
  163. - **Single-file analysis.** Skills analyze one file at a time. Cross-file architectural analysis is not supported yet.
  164. - **Model-dependent quality.** Validated inside Hermes Agent on Gemini 2.5 Flash (full skill loading, tool use, .prism-history.md creation). Also tested on Claude Sonnet (1,485w), Hermes 3 / Llama 405B (439w), and Llama 70B (617w). All follow the skill structure. Sonnet produces the deepest standalone output; Gemini inside Hermes Agent autonomously wrote and executed test scripts.
  165. - **Growth mechanism is minimal.** The `.prism-history.md` feedback loop is an append-only text file — no pruning, no semantic indexing, no validation that adjustments improve subsequent analyses. Future: structured constraint store with semantic deduplication and pruning.
  166. - **No automated benchmarks.** Depth scores (9.8/10, 9.0/10) are from AI-evaluated experiments in the research project, not from standardized external benchmarks. Scoring rubric: 10 = conservation law + meta-law + 15+ bugs with line refs; 9 = conservation law + bugs + structural insight; 8 = multiple concrete bugs + deeper pattern; 7 = real issues + structural reasoning. Evaluated by Claude on real open-source codebases (Starlette, Click, Tenacity, Flask, Rich, Requests).
  167. - **Hermes dependency.** Skills require Hermes Agent. The 7 prisms in `skills/prism-scan/references/` work standalone with any system-prompt-capable tool.
  168. ---
  169. ## The Science
  170. Full research, experiment logs, compression taxonomy, and 33 production prisms: [agi-in-md](https://github.com/Cranot/agi-in-md)
  171. Key findings from the research:
  172. - **40 research rounds**, 1,000+ experiments, 204+ empirical principles
  173. - **Tested on individual files up to 2,700 lines with no quality degradation**
  174. - **Conservation laws are structural** — they persist across all implementations, not just the one analyzed
  175. - **Meta-analysis works** — a second analytical pass genuinely finds what the first pass conceals
  176. - **Cost inversion proven** — structured prompts on cheap models beat expensive models without them
  177. ---
  178. ## License
  179. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

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