This is a submission for the Hermes Agent Challenge: Build With Hermes Agent
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.
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:
The core idea:
A repository should not only store code. It should teach. It should remember. It should safely guide contribution.
Open-source onboarding is broken.
Every new contributor usually has to repeat the same painful discovery process:
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 video:
In the demo, I use:
https://github.com/karpathy/micrograd
Hermes Repo Dojo analyzes micrograd
, a tiny educational autograd engine, and produces:
sigmoid
activation to the Value
classThe final demo flow is:
GitHub URL
↓
Hermes Repo Analysis
↓
Skill Forge
↓
Second Pass Improvement
↓
Patch Arena
↓
Hermes Brain Replay
GitHub repository:
https://github.com/jpablortiz96/hermes-repo-dojo
The app runs locally and invokes Hermes through the CLI from the backend.
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:
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 |
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.
Hermes extracts a repository profile:
For micrograd
, Hermes identifies Python, Autograd, Neural Networks, Pytest, and the key files a contributor should inspect first.
Instead of showing raw folders, Hermes transforms the structure into logical areas.
For micrograd
, it maps:
micrograd/engine.py
micrograd/nn.py
demo.ipynb
, trace_graph.ipynb
, test/test_engine.py
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.
After generating skills, Hermes Repo Dojo runs a second pass.
Before skills:
After skills:
Most agents answer once.
Hermes improves on the second pass.
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:
git push
sudo
apt-get
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.
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.
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
Hermes Repo Dojo separates learning from contribution.
Scout Mode is read-oriented.
It inspects the repository, extracts facts, generates onboarding analysis, and forges skills.
Patch Arena is write-enabled, but only inside a sandbox clone.
The original repository stays untouched.
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.
| 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.
Building this project taught me that agentic products need more than model output.
They need:
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.
The next versions could include:
Most agents answer.
Hermes learns.
Then it safely contributes.