This is a submission for the Hermes Agent Challenge: Build With Hermes Agent
Hermes Repo Dojo: Most Agents Answer. Hermes Learns. Then It Safely Contributes.
Turn any GitHub repo into a living onboarding academy.
Most AI coding agents answer questions about a repository.
Hermes Repo Dojo does something different.
It lets Hermes Agent learn a GitHub repository, transform that understanding into reusable repo-specific skills, improve on a second pass, and safely create a first contribution inside a sandbox clone.
This is not a repo chatbot.
This is an agentic onboarding system.
What I Built
Hermes Repo Dojo is a local AI developer tool that turns any public GitHub repository into a guided onboarding academy for new contributors.
A user pastes a GitHub repository URL, and Hermes Repo Dojo generates:
- 🧬 Repo DNA — purpose, stack, language, commands, and entrypoints
- 🏗️ Architecture Map — logical areas of the codebase
- 🧭 Setup Timeline — what to do first, second, and next
- 🥋 Dojo Map — a contributor learning path from Explorer to Contributor
- ⚔️ Boss Fight — a scoped first contribution with acceptance criteria
- 🧠 Skill Forge — reusable repo-specific Hermes skills
- 🔁 Second Pass — before/after improvement using generated skills
- 🛡️ Patch Arena — a safe sandbox where Hermes creates a first contribution
- 🎬 Hermes Brain Replay — a visual replay of the agent learning trace
The core idea:
A repository should not only store code. It should teach. It should remember. It should safely guide contribution.
The Problem
Open-source onboarding is broken.
Every new contributor usually has to repeat the same painful discovery process:
- Read the README
- Guess the architecture
- Find the right entrypoints
- Figure out install and test commands
- Understand conventions
- Decide what a safe first contribution looks like
Maintainers and senior contributors carry hidden knowledge in their heads.
New contributors do not.
AI agents can answer questions about a repo, but most of that knowledge disappears after the answer.
Hermes Repo Dojo turns that one-time exploration into reusable operational knowledge.
Demo
🎥 Demo video:
In the demo, I use:
https://github.com/karpathy/micrograd
Hermes Repo Dojo analyzes micrograd, a tiny educational autograd engine, and produces:
- Stack: Python, Autograd, Neural Networks, Pytest
- Architecture:
- Core Autograd Engine
- Neural Network Library
- Tests and Demos
- Skills:
- MicrogradAutogradTrace
- MicrogradMLPTraining
- MicrogradGraphViz
- Patch Arena contribution:
- Adds a
sigmoidactivation to theValueclass - Creates a smoke test
- Shows a diff
- Verifies the patch
- Adds a
The final demo flow is:
GitHub URL
↓
Hermes Repo Analysis
↓
Skill Forge
↓
Second Pass Improvement
↓
Patch Arena
↓
Hermes Brain Replay
Code
GitHub repository:
https://github.com/jpablortiz96/hermes-repo-dojo
My Tech Stack
- Hermes Agent CLI
- Hermes terminal toolset
- Hermes skills toolset
- Next.js
- TypeScript
- Tailwind CSS
- Node.js API routes
- Local JSON persistence
- Sandboxed Git workspaces
The app runs locally and invokes Hermes through the CLI from the backend.
How I Used Hermes Agent
Hermes Agent is not decorative in this project.
It is the operating intelligence behind the workflow.
Hermes Repo Dojo invokes Hermes through commands like:
hermes chat --toolsets "terminal,skills" -q "..."
Hermes is used to:
- Inspect cloned repositories
- Reason about architecture and repository structure
- Generate structured onboarding analysis
- Create reusable repo-specific skills
- Improve the onboarding flow on a second pass
- Assist with safe contribution planning
- Power the agent learning narrative behind the product
The key Hermes capabilities I leaned on were:
| Hermes Capability | How Repo Dojo Uses It |
|---|---|
| Terminal tool use | Inspecting local cloned repositories |
| Skills | Creating reusable repo-specific workflows |
| Multi-step reasoning | Analysis → skills → second pass → patch |
| CLI-first architecture | Running Hermes locally from the backend |
| Agentic workflow | Turning codebase exploration into a guided product experience |
The Big Idea
What if every repository could teach itself?
A repository is usually static.
It stores code, but it does not preserve the contributor journey behind the code.
Hermes Repo Dojo makes the repository operational.
It lets Hermes Agent inspect a codebase, extract hidden onboarding knowledge, convert that knowledge into reusable skills, and use those skills to guide better future interactions.
The result is a repository that does not just contain code.
It becomes a living onboarding workflow.
Core Features
🧬 Repo DNA
Hermes extracts a repository profile:
- Summary
- Main language
- Stack
- Entrypoints
- Commands
- Important files
- Architecture areas
For micrograd, Hermes identifies Python, Autograd, Neural Networks, Pytest, and the key files a contributor should inspect first.
🏗️ Architecture Map
Instead of showing raw folders, Hermes transforms the structure into logical areas.
For micrograd, it maps:
-
Core Autograd Engine —
micrograd/engine.py -
Neural Network Library —
micrograd/nn.py -
Tests and Demos —
demo.ipynb,trace_graph.ipynb,test/test_engine.py
🧠 Skill Forge
This is where the project becomes more than analysis.
Hermes generates reusable repo-specific skills.
For the demo, it creates:
MicrogradAutogradTrace
MicrogradMLPTraining
MicrogradGraphViz
The point is simple:
Repository understanding should not disappear after one answer. It should become reusable operational knowledge.
🔁 Second Pass
After generating skills, Hermes Repo Dojo runs a second pass.
Before skills:
- A contributor manually reads README files
- Inspects files without a clear path
- Guesses where to start
After skills:
- Hermes knows the important files
- Hermes has repo-specific procedures
- Hermes can guide a scoped first contribution
Most agents answer once.
Hermes improves on the second pass.
🛡️ Patch Arena
Patch Arena is where Hermes can safely contribute.
This is not reckless auto-coding.
Patch Arena creates a sandbox clone:
workspace/patch-arena/{repo}-{timestamp}
Then Hermes can create or assist with a contribution inside that sandbox only.
Safety rules:
- The original repo is never modified
- No
git push - No
sudo - No
apt-get - No destructive commands
- Diff is shown before the patch is presented
- Verification is run before showing the result
For micrograd, Patch Arena creates a safe first contribution:
+ import math
+
class Value:
""" stores a single scalar value and its gradient """
+ def sigmoid(self):
+ s = 1 / (1 + math.exp(-self.data))
+ out = Value(s, (self,), 'sigmoid')
+
+ def _backward():
+ self.grad += (s * (1 - s)) * out.grad
+ out._backward = _backward
+ return out
It also adds a smoke test and verifies the result.
This is the moment where the product becomes more than an onboarding dashboard.
Hermes does not just explain the repo.
It creates a safe first contribution.
🎬 Hermes Brain Replay
Most agent systems hide the process in logs.
Hermes Brain Replay turns the agent journey into a visible product experience.
It shows:
Repo Ingested
DNA Extracted
Architecture Mapped
Skills Forged
Second Pass Improved
Patch Created
Verification Passed
Learning Trace Completed
This is designed to make the agent’s learning process understandable, visual, and demo-friendly.
Architecture
flowchart TD
A[GitHub Repo URL] --> B[Next.js UI]
B --> C[Analyze API]
C --> D[Clone Repository]
D --> E[Hermes Agent CLI]
E --> F[Repo DNA JSON]
F --> G[Dashboard]
F --> H[Skill Forge]
H --> I[Generated SKILL.md Files]
I --> J[Hermes Skills Directory]
F --> K[Second Pass]
K --> L[Before vs After]
F --> M[Patch Arena]
M --> N[Sandbox Clone]
N --> O[Safe Patch Generation]
O --> P[Diff Preview + Verification]
F --> Q[Hermes Brain Replay]
H --> Q
K --> Q
M --> Q
Safety Model
Hermes Repo Dojo separates learning from contribution.
Scout Mode
Scout Mode is read-oriented.
It inspects the repository, extracts facts, generates onboarding analysis, and forges skills.
Patch Arena
Patch Arena is write-enabled, but only inside a sandbox clone.
The original repository stays untouched.
Demo-safe fallback
Agent providers can hit quota, timeout, or return unsafe output.
To keep the product reliable, Hermes Repo Dojo can fall back to locally extracted repository facts and sandbox-safe patch generation.
That fallback does not replace Hermes Agent. It protects the user experience and environment when provider limits interrupt the live flow.
What Makes This Different
| Typical AI Repo Tool | Hermes Repo Dojo |
|---|---|
| Answers one-off questions | Creates reusable repo-specific skills |
| Explains files | Builds a contributor onboarding path |
| Suggests changes | Generates sandboxed patches with diff and verification |
| Hides agent process in logs | Visualizes the full learning trace |
| Static analysis | Skill generation and second-pass improvement |
This is not a chatbot for repositories.
It is an agentic onboarding system.
What I Learned
Building this project taught me that agentic products need more than model output.
They need:
- Clear workflows
- Safety boundaries
- Visible reasoning artifacts
- Reusable knowledge
- A way to show improvement over time
Hermes Agent was a strong fit because the project is not just about generating text.
It is about tool use, skill creation, repository understanding, and multi-step workflows.
Future Work
The next versions could include:
- GitHub pull request creation
- Maintainer-approved contribution templates
- Multi-repo organization onboarding
- Team skill libraries
- VS Code extension
- CI integration
- Repo health scoring
- Contributor progress tracking
- Enterprise internal repo academy mode
Final Pitch
Most agents answer.
Hermes learns.
Then it safely contributes.
Top comments (0)