iTechGuides is reader-supported. When you buy through links on our site, we may earn an affiliate commission. As an Amazon Associate I earn from qualifying purchases. Learn more
To make a Hermes agent improve reliably, separate procedures from facts. Put a repeatable method—such as an invoice-processing workflow—in a versioned SKILL.md skill. Put short, durable context—such as the invoice directory or a preferred output format—in Hermes’ compact memory files. Use /learn to turn a successful workflow or source into a standards-guided skill, review the generated file, and use the memory tool when you need a fact to survive later sessions. Because memory is injected as a session-start snapshot, begin a fresh session with /new before testing a newly saved preference. This design gives Hermes on-demand procedural knowledge without trying to squeeze long instructions into bounded memory files.
What does “procedural memory” mean in Hermes?
In Hermes, procedural memory is the reusable knowledge that tells an agent how to do a task. The practical implementation is a skill containing a SKILL.md document, rather than a special database labeled procedural memory. Hermes’ Skills System describes skills as “on-demand knowledge documents the agent can load when needed.” They follow progressive disclosure and are compatible with the agentskills.io open standard.
Hermes also has a separate persistent-memory layer for short facts and preferences. The two layers solve different problems:
- Skills: repeatable methods, tool sequences, checks, and recovery instructions. A skill can be edited or deleted by the agent and lives under
~/.hermes/skills/, which is the primary source of truth. - Persistent memory: compact facts about the user or environment. Hermes stores
MEMORY.mdandUSER.mdunder~/.hermes/memories/.
For example, “process invoices by extracting line items, checking totals, and exporting a CSV” is a procedure and belongs in a skill. “Invoices are in /srv/finance/incoming and the user prefers CSV” is compact context and belongs in memory. Mixing the two makes both less reliable: a long procedure can crowd out facts in a bounded memory file, while a one-line preference is awkward to discover as a full skill.
Popular on Amazon
Should a workflow go in SKILL.md or in MEMORY.md?
Use the skill layer for an executable method and the memory layer for a small piece of context that should be present in future conversations. The following distinctions help when a successful run produces several kinds of information.
| Decision axis | SKILL.md skill | MEMORY.md or USER.md |
|---|---|---|
| What it stores | Procedures, ordered actions, inputs, tool calls, expected outputs, validation, and recovery | Durable facts and preferences, such as a directory, naming convention, or output choice |
| Loading cost | Loaded on demand when its trigger matches; detailed references can remain unloaded | Injected into the system prompt as a snapshot when a session starts |
| Mutability | Hermes can modify or delete skills; review changes before consequential use | Writes occur through the memory tool, with the files acting as the persisted record |
| Capacity | The skill can point to expandable material in a references/ directory |
MEMORY.md is limited to 2,200 characters (about 800 tokens); USER.md is limited to 1,375 characters (about 500 tokens), according to Nous Research (2026) |
| Verification boundary | Inspect the generated or edited SKILL.md and run the workflow against acceptance checks |
Confirm that the tool wrote the entry, then start a fresh session to load the updated snapshot |
A useful rule is “method in a skill, pointer in memory.” If the text contains several steps, branching decisions, examples, or safety checks, it is almost certainly too large and too procedural for either bounded memory file.
How do I turn a successful task into a SKILL.md?
Capture a workflow only after it has a clear success criterion and enough detail to repeat. The following sequence keeps an agent from learning a vague slogan instead of a usable procedure.
Recommended Free Tools
- Define the outcome. State what a correct run produces, in what format, and how you will verify it. “Create a reconciled CSV with no duplicate invoice IDs” is testable; “handle invoices better” is not.
- Record the successful path. Note the inputs, tools used, important settings, intermediate artifacts, and the checks that distinguished the successful run from failed attempts. Include assumptions that another session would not know.
- Separate durable context. Move stable environmental facts—such as the location of the input directory or the preferred delimiter—into a short memory entry. Keep the general method in the skill so it can be reused elsewhere.
- Ask Hermes to author the skill. Use
/learnwith a description of the workflow, a local directory, a URL, an SDK, a book, or pasted instructions. Hermes uses that material to author a standards-guided skill and saves it throughskill_manage. - Inspect before trusting. Read the resulting
SKILL.md. Check that triggers are specific, steps are in the right order, destructive actions have confirmation points, and the validation section can detect a bad result. - Run a later task with the skill. Invoke it when its trigger matches a real request. Treat any discrepancy as a concrete revision: add the missing input, check, branch, or recovery step rather than adding a general promise to “be careful.”
The last two steps are an operating practice, not a claim that Hermes guarantees a perfect skill on the first attempt. Generated procedures can contain false assumptions, so a human review point is appropriate before the skill can perform consequential actions.
What should a minimal, testable SKILL.md contain?
A useful file is short enough to scan but explicit enough to execute without guessing. Start with a clear name and a trigger description, then describe the workflow in the order an agent must follow.
1. Name and trigger
Give the skill a name that identifies the task, not the project that happened to produce it. The trigger description should tell Hermes when the skill applies and when it does not. “Reconcile monthly CSV invoices against the ledger” is more selective than “finance helper.”
2. Inputs and preconditions
List required files, formats, permissions, tools, and assumptions. Say what to do when an input is missing or has an unexpected schema. A precondition is also the place to identify data that must not be overwritten.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →Scan for outdated or missing drivers - takes under a minuteDriver Scan →3. Ordered actions and tool calls
Use numbered steps. Name the tool or command, the important arguments, and the artifact produced at each stage. If the same operation has a safe dry-run mode, make that the default in the procedure rather than leaving the choice implicit.
4. Expected outputs
Describe the final files or response, including required columns, naming, location, and encoding where those details matter. A clear output contract lets a later run distinguish “the command completed” from “the task succeeded.”
Also popular on Amazon
5. Validation checks
Specify checks that can fail visibly: row counts, required fields, totals, duplicate detection, schema validation, or a human approval gate. Validation should happen before a move, publish, or delete operation.
6. Recovery instructions
Document what to do when a check fails. A recovery branch might preserve the original file, write diagnostics, ask for a missing value, or stop for human review. Do not hide a failure by silently producing a partial output.
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Scan for outdated or missing drivers - takes under a minute3Repair Windows errors before they cause bigger problems7. References
Keep long examples, decision tables, API details, and background explanations in a references/ directory. The main file can tell Hermes which reference to load for a particular branch. This keeps the initial skill view focused while retaining the detail needed for unusual cases.
An illustrative outline is:
# Invoice reconciliation
Trigger: Use when reconciling invoice CSV files with the monthly ledger.
## Inputs
- Invoice CSV and ledger export
- Read access to the input directory
## Procedure
1. Validate headers and preserve originals.
2. Normalize invoice IDs and dates.
3. Match records and produce a reconciliation report.
4. Export the approved result as CSV.
## Validation
- No duplicate invoice IDs
- Every unmatched row is listed
- Totals reconcile before export
## Recovery
Stop and retain all originals if a schema or totals check fails.
## References
See references/matching-rules.md for exception handling.
This outline demonstrates the information to capture; the exact wording and metadata should match the task you are teaching Hermes.
How does /learn support self-improvement?
/learn is the documented path for converting an external source or a completed workflow into a reusable skill. It accepts a URL, local directory, SDK, book, pasted procedure, or a plain-language description. Hermes authors the skill and persists it through skill_manage, so the result becomes available alongside other installed skills.
A practical loop is:
- Run the task with an explicit success criterion.
- Capture both the successful method and the failure that the method avoided.
- Call
/learnand describe the procedure, its boundaries, and its acceptance checks. - Review the generated file for unsafe actions, unsupported assumptions, missing inputs, and ambiguous outputs.
- Invoke the skill on a later task and compare the result with the criterion.
- Revise the skill when the later run exposes a gap; keep the change tied to an observed failure.
This is self-improvement through explicit artifacts and review, not an assertion that Hermes automatically retrains its underlying model. The durable improvement is the edited procedure that future sessions can load.
Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchPC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11How does Hermes load skills without bloating every prompt?
Hermes uses progressive disclosure. The available levels are skills_list() for skill metadata, skill_view(name) for the complete skill, and skill_view(name, path) for one reference file. This lets the agent identify a relevant skill before loading its full instructions, then fetch supporting material only when a branch needs it.
Every installed skill is available as a slash command. Hermes also supports stacking up to five leading skill commands in one message, which is useful when a task genuinely needs several independent procedures. Keep the default prompt small and invoke a skill when its trigger matches; loading every procedure for every task defeats progressive disclosure and makes conflicts harder to spot.
When two skills appear relevant, choose the one whose trigger and inputs most closely match the request. If the task requires multiple skills, state the intended order and check that their output assumptions are compatible before allowing the second procedure to act on the first procedure’s artifacts.
Also popular on Amazon
How do I save a compact fact with Hermes’ memory tool?
A memory entry is real only when Hermes calls the memory tool. A sentence such as “I’ll remember that” is just conversation text if no tool call writes the file. For correctness-sensitive information, inspect ~/.hermes/memories/MEMORY.md or ~/.hermes/memories/USER.md after the write.
Free tools Windows power users keep installed
One-click scans. No signup required.
Choose the file according to the kind of fact:
USER.mdis appropriate for a user preference or stable instruction, such as a preferred report format.MEMORY.mdis appropriate for durable working context, such as where a project’s inputs are stored or a recurring constraint that is not personal preference.
Keep each entry compact and operational. “Use semicolon-delimited CSV for the monthly report” is useful; a page explaining CSV parsing belongs in a skill reference. The documented limits are strict: MEMORY.md allows 2,200 characters (about 800 tokens) and USER.md allows 1,375 characters (about 500 tokens), as reported by Nous Research in 2026.
Both files are injected into the system prompt as a frozen snapshot at session start. After a successful write, use /new at a natural boundary so a fresh session can load the updated snapshot. Do not judge the write solely by asking the current session to repeat the new fact; that session began with its earlier snapshot.
Why did Hermes forget something after I told it to remember?
The usual causes are a missing tool write, a session snapshot that predates the write, or information that was placed in the wrong persistence layer. Diagnose them in that order.
The agent only said it would remember
Conversation text does not create persistent memory. Check whether a memory tool call occurred and verify the target file. If the call did not happen, ask Hermes to write the concise fact explicitly, then inspect the file.
The file changed, but the current chat still acts unaware
The current system-prompt memory is frozen from session start. Start a fresh session with /new and test the fact there. This is expected snapshot behavior, not evidence that the file write failed.
The “memory” is actually a long procedure
Move the method into a skill. Bounded memory files are designed for compact facts and preferences, while skills can disclose detailed steps and references on demand.
The entry is too vague or stale
Rewrite it as a durable statement with a scope and, when useful, a date or owner. Remove temporary status updates and one-off conclusions so the limited space remains available for information that will affect future decisions.
How can I make the self-improvement loop safe and auditable?
Use explicit boundaries around what the agent may learn and what it may execute. The following controls turn a clever demonstration into an operational process.
Also popular on Amazon
- Require a success criterion. Do not promote a procedure because it produced a plausible-looking answer once. Define the checks that make the result acceptable.
- Preserve originals. A skill should state whether actions are read-only, produce a new artifact, or modify an existing one. Prefer a reviewable output before an overwrite or external publication.
- Review generated skills. Inspect commands, paths, permissions, assumptions, and recovery branches. An agent-managed skill is mutable, so treat changes like code or configuration changes.
- Keep references separate. Put large explanations and exception tables in references, while the main
SKILL.mdremains the execution contract. - Log the reason for revisions. Tie each edit to a failed check, a new input variation, or a clarified requirement. This makes regressions easier to diagnose.
- Use a human gate for consequences. Require approval before deletion, financial submission, credential changes, or other actions whose cost cannot be undone by rerunning the skill.
These controls follow from Hermes’ agent-managed skills, progressive loading, and bounded memory files. They are recommended operating practices, not published Hermes performance or safety guarantees.
What belongs outside procedural memory?
Do not treat either layer as a general-purpose archive. A skill should not become a dump of every conversation, and memory should not become a second manual.
- Temporary session state: keep one-off observations in the task context unless they will change future work.
- Large documentation: store it as a reference file and load it when a procedure needs it.
- Secrets and credentials: do not place sensitive values in a broadly injected memory file or in a skill that does not need them. Use the environment’s approved secret-handling mechanism.
- Unverified guesses: a successful-looking output is not enough to encode an assumption as a durable rule. Mark uncertainty and add a check instead.
- Conflicting preferences: resolve the conflict before writing a compact memory entry; otherwise future sessions may receive ambiguous instructions.
Keeping these categories out prevents a short memory snapshot from becoming noisy and keeps a skill’s trigger meaningful.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.How do I test whether a self-improving agent actually improved?
Hermes’ official material does not provide benchmark figures for task-success uplift, latency, learning gain, or safety. Evaluate a skill with task-level acceptance tests instead of inventing a percentage improvement.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Use representative cases
Run the skill on a normal input, a boundary case, and an intentionally malformed input. Confirm that the normal case reaches the expected output, the boundary case follows the documented branch, and the malformed case stops or recovers safely.
Check artifacts, not just prose
Inspect generated files, logs, row counts, totals, and validation reports. A polished explanation cannot substitute for a missing artifact or a failed check.
Compare with the pre-skill workflow
Record which manual decisions the skill standardizes and which still require a person. The useful question is whether the repeatable method is clearer and more auditable, not whether the agent claims to have “learned.”
Retest after edits
When a skill changes, rerun the cases that motivated the edit and at least one case from another branch. This catches a narrowly fixed procedure that breaks an earlier path.
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Worked design: invoice processing with both layers
Suppose a team wants Hermes to process invoices consistently. The reusable method is a skill; local facts are memory entries.
Also popular on Amazon
Put the method in a skill
The skill can require the agent to validate headers, preserve originals, normalize identifiers, match records, produce an exceptions report, and export only after totals reconcile. Its recovery section can instruct Hermes to stop and retain source files when a schema check fails. Matching rules and examples can live in references/.
Put local facts in memory
A compact entry can say that the current invoice directory is /srv/finance/incoming and that the monthly report must be semicolon-delimited CSV. Those facts are useful across tasks but do not explain how reconciliation works.
Promote a successful run
After a run meets the reconciliation checks, call /learn with the workflow description and the observed checks. Review the generated SKILL.md, confirm that it does not hard-code a temporary filename, and invoke it on a later month. If a new supplier uses a different date format, add a documented normalization branch rather than storing the supplier’s entire procedure in memory.
What is the practical architecture for Hermes procedural memory?
A durable setup has four layers working together:
- Prompt-time selection: Hermes identifies relevant skill metadata with
skills_list(). - Procedure loading: It opens the selected
SKILL.mdwithskill_view(name). - Just-in-time detail: It loads a single supporting file with
skill_view(name, path)when a branch needs it. - Session context: It receives the compact
MEMORY.mdandUSER.mdsnapshot at session start.
This architecture keeps recurring facts available without paying the prompt cost of every procedure, while preserving detailed instructions for the moment they are relevant. It also creates two verification points: inspect the skill or reference file for procedural changes, and verify the memory write plus a fresh-session reload for fact changes.
Operational checklist for each new skill
- Is the name specific enough to avoid accidental triggering?
- Does the trigger state both the intended task and its boundary?
- Are inputs, permissions, tools, and expected outputs explicit?
- Are actions ordered, with destructive steps separated from preparation?
- Can every important result be validated objectively?
- Does each failure branch say whether to retry, repair, ask, or stop?
- Are long examples and decision tables in
references/? - Have you reviewed the generated file before allowing consequential actions?
- Did you place only compact, durable facts in memory?
- After writing memory, did you verify the file and test from a fresh
/newsession?
Following this checklist makes Hermes’ improvement concrete: a tested, reviewable procedure becomes a skill, while a small set of verified facts remains available as session context.
Frequently Asked Questions
Can Hermes learn from a local folder as well as from a web source?
Yes. The documented /learn flow accepts a local directory as well as a URL, SDK, book, pasted procedure, or workflow description. The resulting material is authored as a skill and saved through skill_manage, so review the generated file regardless of the source type.
Where should a large decision table for a skill live?
Keep it in the skill’s references/ directory and load that file only for the branch that needs it. The main SKILL.md should state when to consult the table and what decision it controls.
Does editing a skill immediately change every running Hermes session?
A skill is loaded when relevant, so a later invocation can use the edited file. Memory is different: its system-prompt content is a session-start snapshot, which is why a fresh session is needed to test a newly written memory fact.
How can I tell whether a memory claim was really persisted?
Look for an actual memory tool call, inspect the corresponding file under ~/.hermes/memories/, and then test from a new session. A conversational confirmation without the tool write does not establish persistence.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
