How Hermes Agent memory, skills, and self-learning work
Follow how Hermes Agent saves durable facts, recalls past sessions, builds reusable skills, and separates live memory from offline training.
The whole story in 6 lines
Hermes grows by routing experience into bounded facts, searchable episodes, reusable skills, and optional offline data.
- Hermes changes future behavior by saving artifacts, not by changing model weights during the chat.
- Small curated memory keeps durable facts ready while temporary progress stays in session history.
- Past sessions remain searchable and are summarized only when the current task needs them.
- A successful workflow can become a validated skill that later sessions load on demand.
- Post-response review and compression boundaries create deliberate chances to consolidate learning.
- Trajectory export supports optional offline work, which remains separate from live prompt-time learning.
The repeated correction
Yesterday, a staging deployment needed three corrections: use port 2222, choose podman, and preview the diff before restart. Today, repeating those corrections feels like the agent learned nothing.
Hermes has several places to preserve experience. A fact records something stable, a skill records a method, an episode preserves a conversation, and a trajectory keeps training-shaped data.
The failed repeat now opens into six questions about routing and reuse. Each stage follows one piece of experience from the first task into a later session.
Keep the original deployment in mind because it anchors every mechanism. Now let us start with the most fundamental idea: what Hermes means when it says learning.
Learning means durable artifacts
We begin with one completed deployment and its full trace of messages and tool results. Hermes treats that experience as structured runtime data, while model parameters stay outside the saved trace. That boundary is the whole architecture's starting point.
The trace can produce four different artifacts because each serves a different future need. Stable facts, reusable methods, searchable conversations, and offline trajectories do not belong in one giant memory blob.
The four artifacts are ready to persist while the model remains locked. Which part actually changes during this live conversation?
Memory notes, a skill folder, a session record, and a trajectory file now persist beside the unchanged model. Future behavior improves because Hermes can route those artifacts back into later work.
Here is the key distinction: prompt-time learning changes stored context and procedures, not the live neural network. Next, we will open the smallest prompt-hot store and see why it stays bounded.
Small memory earns prompt space
Now that artifacts are separate, we can ask what deserves permanent prompt space. Hermes keeps environment facts in MEMORY.md and user preferences in USER.md under the active profile.
A proposed entry first passes injection checks, duplicate checks, and a character budget. The default source limits are 2,200 characters for MEMORY.md and 1,375 for USER.md.
Temporary task progress follows a different route because it will soon become stale. The complete conversation still persists in the session archive, so rejecting prompt-hot memory does not erase history.
A stable preference passes the gate and is written atomically to disk. The current cached prompt stays frozen, so the new fact becomes prompt-visible at the next rebuild boundary.
Try both Lesson options and compare the destination after the policy gate. Temporary progress falls into the archive, while a stable preference waits for the next prompt rebuild.
Declarative memory works like a small index of facts worth carrying everywhere. Next, we will search the much larger session archive when a future task needs detailed history.
Episodes stay cold until searched
We just kept permanent facts small, but a deployment conversation contains much richer detail. Hermes stores messages, tool calls, timestamps, token counts, and lineage in SQLite with an FTS5 index. That archive can outlive the active context window.
A later deployment query enters the search index and matches older message spans. Results are grouped by session so related tool traces stay connected to the conversation that produced them.
Several useful sessions match the query, but their transcripts are much too large for permanent prompt space. Does Hermes load the whole archive now?
FTS5 narrows the archive, then an auxiliary model turns the top sessions into focused recaps. The current task receives useful history without carrying every old message in its hot prompt.
Episodic memory preserves what happened, while declarative memory preserves only what should stay ready. Next, we will promote a successful method into something stronger than a remembered conversation.
A success becomes a procedure
★ If you remember one thing · A solved workflow becomes an inspectable skill that a later task can load and follow.
The recalled deployment proves more than a fact because it contains a repeatable method. Hermes can preserve that method between sessions as a skill folder with SKILL.md and optional scripts, references, templates, or assets.
The successful trace supplies five ordered actions: connect correctly, render configuration, preview changes, restart with podman, and verify health. Validation and security scanning protect the resulting procedure before reuse.
A fresh deployment request now arrives, and the earlier trace has already proved useful. What should Hermes create so the method can return intact?
The five receipts fold into one skill file, and that procedure enters the next deployment through on-demand loading. A compact index advertises the skill without placing every instruction in the prompt.
Skills stay editable, so a later correction can patch the procedure instead of starting over. Next, we will see how Hermes notices learning opportunities after the main answer is already delivered.
The answer comes before review
We now have facts, episodes, and skills, but the main agent may not save every useful lesson while solving a hard task. Hermes tracks configurable review counters for memory turns and skill-heavy iterations.
The user-facing answer remains the primary path. Review eligibility accumulates quietly, so Hermes does not spend extra inference on consolidation after every ordinary turn.
When a configured threshold is reached, the completed interaction becomes a candidate for review. The runtime can ask whether a stable fact or reusable method deserves promotion.
The answer reaches the user first, then a background agent branches from the same transcript and writes worthwhile artifacts. This separation protects the task path while still creating deliberate learning time.
Compression creates another boundary because old context is about to disappear. Hermes offers a final memory flush and notifies external providers before summarization. Next, we will separate this runtime loop from offline model improvement.
Two clocks of improvement
Consolidation improves the next prompt without touching neural weights. Memory snapshots, skill indexes, and recalled summaries can change a later session as soon as the runtime rebuilds or retrieves context.
Hermes can also export tool-rich conversations as JSONL trajectories. Batch processing and trajectory compression prepare those records for later evaluation or training workflows well outside the live chat loop.
The runtime path is already feeding artifacts into a new session, while the trajectory waits in a separate pipeline. When can model weights change in this design?
Two clocks now diverge. Prompt-time artifacts help the very next session, while exported trajectories may support a later model version only after separate offline evaluation or training.
This boundary prevents the phrase self-learning from promising instant retraining. Hermes grows immediately through inspectable runtime artifacts, and offline model improvement remains optional. Now let us step back and see the whole picture together.
The complete learning loop
We started by separating self-learning from online weight updates. Hermes changes future behavior by writing inspectable artifacts around an otherwise unchanged live model.
Then we learned why small declarative memory earns permanent prompt space. Stable facts survive, while temporary progress remains safely available in the session archive.
Next, episodic recall searched old sessions and summarized only the useful matches. Rich history stayed cold until the current task asked for it.
We turned a successful deployment into a validated skill. Its compact index stayed cheap, while full instructions loaded only when a later task needed them.
We also separated the primary answer from post-response review and compression-time extraction. Those boundaries create deliberate chances to preserve lessons without delaying the user.
Finally, we drew a firm line around offline learning. Hermes can export trajectories, but training a later model remains separate from the live agent loop.
The full loop now converges on one idea: Hermes grows by turning experience into the right artifact, then routing that artifact back when future work can use it.
The whole story in 6 lines
Hermes grows by routing experience into bounded facts, searchable episodes, reusable skills, and optional offline data.
- Hermes changes future behavior by saving artifacts, not by changing model weights during the chat.
- Small curated memory keeps durable facts ready while temporary progress stays in session history.
- Past sessions remain searchable and are summarized only when the current task needs them.
- A successful workflow can become a validated skill that later sessions load on demand.
- Post-response review and compression boundaries create deliberate chances to consolidate learning.
- Trajectory export supports optional offline work, which remains separate from live prompt-time learning.