Improvement During Use

Improvement During Use can be understood as skills improving themselves while the agent works. This is the part that most distinguishes Hermes from the “write once, use forever” skill model: the agent can edit its own skills after working, through the skill_manage tool. This is exactly the “procedural memory” — the place where experience from a work session does not vanish when the conversation ends.

When the agent writes a skill on its own

Not always — three specific situations trigger it:

• When the agent has just discovered a multi-step procedure worth repeating later
• When it hit an error, went down a dead end, and finally found the right way
• When you correct the way it was doing something

A real example: you ask the agent to connect to an unfamiliar internal API, it fumbles a few times (wrong auth header, wrong payload format), and finally finds the right approach. Instead of that knowledge dying with the conversation, the agent saves it as a skill — next time it meets a similar job, it goes straight to the right way without repeating the trial-and-error steps.

Operations the agent can perform on its own

Controlling the degree of automation — the write-approval gate

By default, the agent is free to write skills without asking you. In environments that need more caution — small models that easily misjudge what they have “learned”, or high-security environments — you can enable the approval gate:

skills:
  write_approval: true

When enabled, every skill change (including those from the background review that runs after each session) is staged instead of applied immediately:

/skills pending              # list the changes awaiting approval
/skills diff <id>            # inspect a change in detail (diff form)
/skills approve <id>         # agree to apply it
/skills reject <id>          # refuse and discard it

Notable point: pending changes survive restarts — they are stored in ~/.hermes/pending/skills/ and are not lost when you shut Hermes down and start it again.

Skills and Memory cooperate, without overlapping

These two mechanisms split the work clearly: memory stores the small facts that must always be present in context (e.g. “the user likes reports as tables, not prose”), while skills store long procedures that only need to be loaded when relevant. This separation keeps context from ballooning with details that are only needed once in a while.

Notes

• In production environments or when using small models, enable write_approval: true from the start — free skill writing sounds nice, but a wrong skill that the agent creates and then confidently reuses can spread its error much further than a single wrong answer.
• Run /skills pending periodically to re-check what the agent “thinks” it has learned — this is also an indirect way to understand how the agent is modeling your work on its own.
• Prefer letting the agent use patch over edit whenever possible — it saves tokens, and small diffs are far easier to review when the approval gate is on.