The six-stage path (H6) that takes you from chat-window prompting to operating Hermes — a self-evolving AI agent with persistent memory, a growing skill library, and a multi-agent workforce under your command.
Get a free inside look at “Memory Systems That Compound: The Three-Tier Stack” — the video overview.
By the numbers
You spent forty minutes teaching your assistant the codebase — the conventions, the constraints, the reasons behind them. Then the session ended, and tomorrow you teach it all again from zero. No persistent memory, no skill library, no improvement loop. Every session starts at the same baseline, and you are the only component in the system that learns. You're not running an agent; you're doing the agent's job for it, one paste at a time.
Six months from now you're still re-explaining your stack to a stateless chat window while your backlog compounds. Meanwhile the engineers who built their own agents early are compounding: their agent remembers every architectural decision it has seen, wrote itself a skill for the deploy pipeline last sprint and reused it this one, and delegates to specialist sub-agents overnight. Same models you have access to — different architecture around them. Memory, skills, and self-evolution compound like interest.
Hermes is a self-evolving AI agent: an architecture you build once that then improves itself. H6 is the six-stage path from first principles to a multi-agent workforce, and each stage ships a working layer of your own instance. H1 Architecture stands up the agent loop, tool layer, and runtime. H2 Soul defines the fixed identity that frames every decision. H3 Memory gives the agent a three-tier stack so context survives every session. H4 Skills grows a versioned library the agent writes, tests, and reuses. H5 Evolution wires the reflection loop and the GEPA optimizer. H6 Workforce scales from one agent to a managed team of delegated specialists.
Junior-to-mid engineers learn agent architecture, memory systems, and tooling fundamentals most engineers won't touch for years. Mid-to-senior engineers who have hit the assistant ceiling get compounding leverage and the systems-design depth that separates senior engineers from power prompters. Senior-to-staff engineers get the architecture — how memory, self-evolution, and multi-agent orchestration compose — and a workforce design they can run for a whole team and defend in a design review.
Thirty video lessons across six modules, six hands-on build sessions that ship your own Hermes instance (not toy code), and eighteen brand-locked reference infographics. The kit includes four lead-magnet PDFs — the H6 cheatsheet, architecture quickstart, memory audit, and skills-evolution playbook — plus the Hermes starter scaffold, self-evolution loop templates, skill-library conventions, and multi-agent delegation and approval-gate configs. Lifetime access; every future update included.
Hermes crossed 90,000 GitHub stars within two months of release — one of the fastest-growing open-source agent frameworks on record.
Hermes ships a 687-skill Hub across 18 categories, so an agent's capability library starts large and grows through both community taps and skills it authors itself.
6 modules, each ending in a deliverable.
Hermes is an open-source, self-evolving AI agent framework built around a single AIAgent class that unifies execution, routing, and learning. Unlike a chatbot, it keeps persistent memory across sessions, writes and reuses its own skills, and improves itself between tasks — all running on your own hardware.
Assistants are stateless and session-bound. Hermes accumulates: it remembers context across sessions in a three-tier memory stack, grows a versioned skill library, and runs a self-evolution loop. Assistants restart at the same baseline every time; Hermes compounds.
A working Hermes instance on your own infrastructure: a running ReAct agent loop (H1), a defined SOUL.md identity (H2), a three-tier memory stack (H3), a self-evolving skill library (H4), an evolution loop with GEPA and safety rails (H5), and a multi-agent workforce with delegation (H6) — produced across six hands-on build sessions.
H1 Architecture, H2 Soul, H3 Memory, H4 Skills, H5 Evolution, and H6 Workforce. Each stage ships a working layer of your agent and ends with a hands-on build session.
SOUL.md is a static, hand-authored identity file loaded in slot #1 of the system prompt, before memory or skills. It defines persona, tone, communication style, and hard limits, and acts as the fixed frame through which all of the agent's memory and skill evolution is filtered.
Through a three-tier memory system: Tier 1 is two capped Markdown files (MEMORY.md and USER.md) frozen into the prompt; Tier 2 is a SQLite database of every past conversation searchable on demand; Tier 3 is optional external memory providers that prefetch relevant context before each turn.
Skills are Markdown files with YAML frontmatter that encode procedures. The agent uses the skill_manage tool to author them autonomously after complex tasks or successful error recovery, then reuses them later. Progressive disclosure keeps even a 687-skill catalog token-efficient.
GEPA (Genetic-Pareto Prompt Evolution) is an offline optimization pipeline that improves skills using real execution traces rather than the agent's self-assessment. It runs an evolutionary search, scores candidates with an LLM-as-judge, enforces 100% test-pass and size gates, and ships the winner as a human-reviewed Pull Request — for about $2–$10 per run with no GPU.
The agent evolves capabilities, never constraints. SOUL.md and hard limits stay fixed, the Curator archives rather than deletes (with tar.gz snapshots before every pass and one-command rollback), and GEPA changes require human approval via Pull Requests.
Yes. Profiles let you clone fully isolated specialists — programmer, designer, researcher — each with its own config, memory, skills, and SOUL.md. You then wire a delegation protocol (planner, builders, reviewer) and manage them as a workforce, with the 90-turn budget shared across the team.
Linux, macOS, or WSL2 with Python 3.11+. State lives under ~/.hermes/. Hermes also runs on Docker or a cloud GPU server, and works with Claude, GPT, Gemini, or local Ollama models via a two-line provider change.
No. This is systems engineering — APIs, storage, loops, and guardrails — not model training. Engineers from junior to staff complete the course with the same materials.
Thirty video lessons across six modules, six hands-on build-session recordings, eighteen reference infographics, and four lead-magnet PDFs (cheatsheet, architecture quickstart, memory audit, skills-evolution playbook). Access is lifetime, with every future update included.
Those are assistants: stateless, session-bound, waiting on your next prompt. Hermes is an agent you own — it keeps memory across sessions, grows its own skill library, and improves itself between tasks. The course teaches you to build and run it; your assistants become tools it uses, including delegating coding execution to the Claude Code CLI.
The framework, the six build sessions, and the kit — one payment, lifetime access, fully guaranteed. Hermes takes one weekend to stand up; the compounding lasts a career.
