Skip to content
Back to search

hermes-dojo

Self-improvement system for Hermes Agent. Monitors performance, finds weak skills, fixes them with self-evolution, reports results.

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/yonkoo11--hermes-dojo/badge.svg)](/listings/yonkoo11--hermes-dojo)

HTML

<a href="/listings/yonkoo11--hermes-dojo"><img src="/api/listings/yonkoo11--hermes-dojo/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 as a Hermes skill
git clone https://github.com/Yonkoo11/hermes-dojo.git
cd hermes-dojo
./install.sh

# Seed demo data (optional, for testing)
cd ~/.hermes/skills/hermes-dojo/scripts
python3 seed_demo_data.py --days 7

# Run the full pipeline
python3 demo.py --reset

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.

SKILL.md · Manifest · 141 lines

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

  1. ---
  2. name: hermes-dojo
  3. description: >
  4. Continuous self-improvement system for Hermes Agent. Analyzes your past sessions
  5. to find recurring failures and skill gaps, then automatically creates or patches
  6. skills and runs self-evolution to fix them. Set it to run overnight and wake up
  7. to a better agent. Use /dojo to start.
  8. version: 1.0.0
  9. license: MIT
  10. metadata:
  11. author: yonko
  12. hermes:
  13. tags: [self-improvement, self-evolution, analytics, meta-agent]
  14. category: agent-improvement
  15. requires_toolsets: [terminal]
  16. allowed-tools: Bash(python3:*) Read Write skill_manage delegate_task session_search memory
  17. ---
  18. ## Overview
  19. Hermes Dojo is your agent's training gym. It reads your past sessions, finds where
  20. the agent struggles, creates or improves skills to fix those weaknesses, and tracks
  21. improvement over time.
  22. The core loop: **measure → identify weakness → fix → evolve → verify → report**
  23. ## Commands
  24. - `/dojo` or `/dojo analyze` — Analyze recent sessions for failure patterns
  25. - `/dojo improve` — Fix the top weaknesses (patch skills + run self-evolution)
  26. - `/dojo report` — Show current performance metrics and improvement history
  27. - `/dojo history` — Show learning curve over time
  28. - `/dojo auto` — Set up overnight cron: analyze + improve + report at 6am
  29. - `/dojo status` — Quick summary of agent health
  30. ## Workflow
  31. ### Step 1: Analyze
  32. Run `python3 ~/.hermes/skills/hermes-dojo/scripts/monitor.py` to scan recent sessions.
  33. This reads `~/.hermes/state.db` and produces a JSON report with:
  34. - Per-tool success/failure rates
  35. - Error patterns (grouped by tool and error type)
  36. - User correction signals (messages containing "no,", "wrong", "I meant", "not what I")
  37. - Skill gap detection (repeated manual tasks with no skill)
  38. - Session-level metrics (tool calls per session, retry patterns)
  39. Present the results as a clear dashboard:
  40. ```
  41. === Hermes Dojo Analysis ===
  42. Sessions analyzed: 23 (last 7 days)
  43. Total tool calls: 156
  44. Overall success rate: 78%
  45. Top Weaknesses:
  46. 1. terminal_run: 73% success (12 failures) — common error: "command not found"
  47. 2. web_extract: 81% success (4 failures) — common error: "timeout"
  48. 3. No skill for: CSV parsing (requested 4 times)
  49. User Corrections Detected: 7
  50. - 3x wrong file path
  51. - 2x wrong command syntax
  52. - 2x misunderstood request
  53. ```
  54. ### Step 2: Improve
  55. For each identified weakness, decide the fix:
  56. **A) Existing skill fails → patch it:**
  57. 1. Read the current skill's SKILL.md
  58. 2. Analyze the failure patterns from Step 1
  59. 3. Use `skill_manage` with action "patch" to add error handling, better instructions, or edge case coverage
  60. 4. Log the change
  61. **B) No skill exists for a recurring need → create one:**
  62. 1. Analyze the session patterns where this capability was needed
  63. 2. Use `skill_manage` with action "create" to make a new skill
  64. 3. Include specific instructions based on what worked in past sessions
  65. 4. Log the creation
  66. **C) Skill exists but needs deeper improvement → run self-evolution:**
  67. 1. Run: `cd ~/.hermes/hermes-agent-self-evolution && .venv/bin/python3 -m evolution.skills.evolve_skill --skill <name> --hermes-repo ~/.hermes --iterations 5 --eval-source synthetic`
  68. 2. This uses GEPA to analyze execution traces and propose targeted improvements
  69. 3. Review the evolution output — accept if score improved
  70. 4. Log before/after scores
  71. ### Step 3: Verify
  72. After improvements:
  73. 1. Re-run `monitor.py` to compute new metrics
  74. 2. Compare before/after success rates
  75. 3. If improvement < 5%, flag for manual review
  76. 4. Store results in metrics history
  77. ### Step 4: Report
  78. Run `python3 ~/.hermes/skills/hermes-dojo/scripts/reporter.py` to generate a report.
  79. Format for Telegram delivery:
  80. ```
  81. 🥋 Hermes Dojo — Overnight Report
  82. 📊 Analyzed: 23 sessions, 156 tool calls
  83. 📈 Overall: 78% → 85% (+7%)
  84. ✅ Improved:
  85. • terminal_run: 73% → 96% (added PATH check)
  86. • web_extract: 81% → 95% (added retry + timeout)
  87. 🆕 New skill created:
  88. • csv-handler: for CSV parsing you keep asking about
  89. ⚠️ Still working on:
  90. • File path resolution (need more examples)
  91. 📉 Learning curve: 71% → 78% → 85% (3 days)
  92. ```
  93. ### Step 5: Track
  94. Run `python3 ~/.hermes/skills/hermes-dojo/scripts/tracker.py save` to persist metrics.
  95. Run `python3 ~/.hermes/skills/hermes-dojo/scripts/tracker.py history` to show the learning curve.
  96. ## Setting Up Overnight Cron
  97. When the user says `/dojo auto`:
  98. Set up a cron job that runs at 6:00 AM daily:
  99. "Run /dojo analyze, then /dojo improve on the top 3 weaknesses, then send the report to my home channel."
  100. This makes the agent literally improve while you sleep.
  101. ## Important Notes
  102. - Never modify bundled skills (in hermes-agent/skills/). Only modify user skills in ~/.hermes/skills/
  103. - Self-evolution requires ~/.hermes/hermes-agent-self-evolution to be cloned
  104. - Metrics are stored in ~/.hermes/skills/hermes-dojo/data/metrics.json
  105. - Each analysis run is timestamped so you can track improvement over days/weeks
README.md · README · 127 lines

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

  1. # Hermes Dojo
  2. **Your agent, getting better while you sleep.**
  3. Hermes Dojo is a self-improvement system for [Hermes Agent](https://github.com/NousResearch/hermes-agent) that watches how your agent performs, finds its weakest skills, fixes them with self-evolution, and shows you the results.
  4. ## The Problem
  5. Your AI agent makes the same mistakes every day. You correct it, it forgets next session. Skills exist but nobody knows which ones work well and which ones silently fail. Self-evolution exists but nobody uses it because there's no signal about WHAT to evolve.
  6. ## The Solution
  7. Dojo closes the feedback loop:
  8. ```
  9. measure → identify weakness → evolve → measure again → report
  10. ```
  11. It turns "the agent that grows with you" from a tagline into reality.
  12. ## How It Works
  13. ### 1. Performance Monitor
  14. Reads your agent's session logs from `state.db`. Identifies failures: tool errors, retry loops, user corrections ("no, I meant..."), explicit complaints. Tracks per-skill success rates.
  15. ### 2. Weakness Analyzer
  16. Categorizes root causes and ranks improvement opportunities:
  17. - "web_extract fails 100% of the time. Root cause: no retry logic for timeouts"
  18. - "No skill exists for CSV parsing, but user asked for it 5 times"
  19. ### 3. Auto-Fixer
  20. For each weakness:
  21. - Skill exists but fails → patch it with targeted error handling
  22. - No skill exists → create one based on session patterns
  23. - Run self-evolution (GEPA) on weak skills for measurable improvement
  24. ### 4. Reports
  25. Generates reports for CLI or Telegram delivery with deltas, sparklines, and actionable summaries.
  26. ### 5. Learning Curve
  27. Stores daily metrics. Shows improvement over days/weeks. Proof that the agent is actually growing.
  28. ## Quick Start
  29. ```bash
  30. # Install as a Hermes skill
  31. git clone https://github.com/Yonkoo11/hermes-dojo.git
  32. cd hermes-dojo
  33. ./install.sh
  34. # Seed demo data (optional, for testing)
  35. cd ~/.hermes/skills/hermes-dojo/scripts
  36. python3 seed_demo_data.py --days 7
  37. # Run the full pipeline
  38. python3 demo.py --reset
  39. ```
  40. ## Commands (via Hermes Agent)
  41. | Command | What it does |
  42. |---------|-------------|
  43. | `/dojo analyze` | Analyze recent sessions for failures |
  44. | `/dojo improve` | Fix weakest skills + run self-evolution |
  45. | `/dojo report` | Generate improvement report |
  46. | `/dojo history` | Show learning curve over time |
  47. | `/dojo auto` | Set up overnight cron (analyze + improve + report) |
  48. ## Architecture
  49. ```
  50. hermes-dojo/
  51. ├── SKILL.md # Main orchestrator (Hermes skill format)
  52. ├── scripts/
  53. │ ├── monitor.py # Reads session SQLite, computes metrics
  54. │ ├── analyzer.py # Categorizes failures, ranks weaknesses
  55. │ ├── fixer.py # Patches skills, creates new ones, runs evolution
  56. │ ├── reporter.py # Generates CLI/Telegram reports
  57. │ ├── tracker.py # Stores/retrieves learning curve data
  58. │ ├── seed_demo_data.py # Demo data generator
  59. │ └── demo.py # Full pipeline demo runner
  60. ├── references/
  61. │ └── failure_patterns.md
  62. └── data/
  63. └── metrics.json # Historical performance data
  64. ```
  65. ## Hermes Features Used
  66. | Feature | How Dojo Uses It |
  67. |---------|-----------------|
  68. | Skills system | Dojo IS a skill; it creates/patches other skills |
  69. | Self-evolution (GEPA) | Evolves weak skills via DSPy optimization |
  70. | Session search | Reads past sessions to identify failure patterns |
  71. | Cron scheduler | Runs overnight improvement cycle |
  72. | Multi-platform | Morning report on Telegram |
  73. | skill_manage | Creates and patches skills programmatically |
  74. ## Requirements
  75. - [Hermes Agent](https://github.com/NousResearch/hermes-agent) v0.2.0+
  76. - Python 3.10+
  77. - [hermes-agent-self-evolution](https://github.com/NousResearch/hermes-agent-self-evolution) (for GEPA)
  78. ## Built for
  79. Nous Research Hermes Agent Hackathon (March 2026)
  80. ## Contributing
  81. Issues and pull requests welcome. The analyzer in particular benefits from
  82. real-world failure patterns — if you see a false-positive recommendation or a
  83. weak-skill misclassification, please open an issue with the offending tool
  84. name and top error string.
  85. Thanks to external contributors:
  86. - [@eggressive](https://github.com/eggressive) — root-cause classification and
  87. description-based gap detection in the weakness analyzer (#3)
  88. ## License
  89. MIT — see [LICENSE](LICENSE).
  90. ---
  91. Built on [Hermes Agent](https://github.com/NousResearch/hermes-agent) by [Nous Research](https://nousresearch.com)

Ratings and comments

Sign in to rate this skill.

Sign in

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