Hermes Skills: Reusable, Approval-Gated Workflows

Skills are how a private AI assistant reuses procedure without turning every chat into a long prompt. If your assistant triages leads, drafts meeting briefs, or prepares weekly reports — and the standard of quality should not change every time — that work belongs in a skill.

The concept started as OpenClaw skills and now lives in Hermes as a first-class feature. If you are setting up your first private AI worker, skills are the layer where you encode the procedures that worker should follow.

What are Hermes skills?

A Hermes skill is a reusable, approval-gated procedure file that tells your assistant how to handle a specific type of repeated work. Each skill defines a purpose, inputs, allowed tools, blocked actions, approval gates, and an output format. When a task matches the skill's trigger conditions, Hermes loads it and follows the procedure instead of guessing from chat context. Skills are narrow, inspectable, and easy to retire when the work changes.

The short answer

Create a skill when a workflow repeats, has clear inputs, uses known tools, and needs consistent stop conditions. Keep each skill narrow — one task, one approval model, one source of truth.

• Do write skills for repeated work: lead triage, meeting briefs, CRM follow-up, weekly reports, support drafts, content prep.
• Do include purpose, allowed tools, blocked actions, approval gates, and output format.
• Do test on a low-risk example before trusting it with customers, money, or production.
• Don't use a skill as a dumping ground for all context — memory and project state belong elsewhere.
• Don't give a skill broad authority. If it needs two approval models or two sources of truth, split it.

Concrete example: lead follow-up skill

A small agency wants Hermes to triage new leads and draft replies. Without a skill, the owner re-explains the process every time. With a skill, Hermes loads the procedure and follows it.

# Lead Follow-Up Draft Skill

Purpose: Prepare fast, accurate reply drafts for new qualified leads.

Use when:
- The user asks Hermes to triage new leads.
- A scheduled lead review job asks for follow-up drafts.

Inputs:
- Source message or approved lead inbox.
- Current offer notes.
- Calendar availability summary when provided.
- CRM history when available.

Allowed actions:
- classify the lead;
- summarize relevant context;
- draft a reply;
- suggest a CRM note;
- ask for approval.

Blocked actions:
- send email without approval;
- quote price;
- promise availability;
- mark a deal closed;
- delete or archive the source message.

Approval gate:
- Before any outbound message or CRM status change, show source,
  proposed action, draft, risk, and exact result after approval.

Output:
- lead classification;
- one-paragraph context summary;
- reply draft;
- recommended next action;
- approval request or escalation reason.

That is specific enough to be useful and narrow enough to review. The owner sees the source, the draft, and the risk before anything goes out.

How it works

A skill is a reusable operating procedure. It answers one practical question: "How should Hermes do this kind of work?"

Each skill should include:

• Purpose: the result the skill should produce.
• Use when: when Hermes should load or follow the skill.
• Inputs: files, messages, systems, or user details required.
• Allowed tools: what Hermes may read or draft with.
• Blocked actions: what it must not do.
• Approval gates: when it must stop and ask.
• Output format: what the owner should receive.
• Escalation rules: when to hand off to a person.

Keep it short enough that the owner can inspect it. A skill is not a policy manual.

Skills, memory, and runbooks serve different purposes — do not blur them:

• Runbook: the business operating rules for a workflow.
• Skill: the reusable procedure for a specific task inside the workflow.
• Memory: stable preferences and durable facts that should persist.
• Project file: current state the assistant can reread.

Example: "Always ask before quoting price" belongs in the runbook and relevant skills. "The owner prefers short customer replies" lives in memory. "This week's availability is limited" belongs in a current status file or the immediate request.

Approvals should be explicit, not implied. Require approval before Hermes sends customer messages, changes CRM stage, posts public content, edits production systems, deletes source material, quotes price, issues refunds, or makes reputation-sensitive commitments. For each approval, tell Hermes what evidence to show: source, proposed action, exact output, and risk.

Good skill candidates: classify leads and draft replies, prepare meeting briefs, summarize Slack threads, turn tickets into support drafts, create weekly reports, review content outlines, prepare post-call follow-up tasks.

Weak candidates: "be strategic," "handle sales," "manage support," "make the right decision," one-off research, anything where the owner cannot state the stop condition.

How to apply it

1. Choose one repeated low-risk workflow. Pick something you do the same way every time — not your most complex process.
2. Write the current manual process in 5–10 bullets. Do not invent new steps. Capture what you actually do today.
3. Add allowed tools and blocked actions. Be specific about what Hermes may read, draft, or change — and what it must never touch.
4. Add approval gates. Define exactly when Hermes must stop and show you the source, proposed action, draft, and risk before proceeding.
5. Define the output format. What should you receive? A classification, a draft, a summary, a recommended next action?
6. Test on one real example. Check: did Hermes use the right source, follow the procedure in order, stop at the approval point, produce the expected format, and cite uncertainty instead of guessing?
7. Save corrections into the skill. If the same correction appears twice, update the skill — do not keep retyping it in chat.
8. Use it for a week before expanding scope. The first skill should save review time, not prove autonomy.

Run the test against a real but low-risk example. If Hermes used the wrong source, skipped the approval gate, or produced a different format, fix the skill before trusting it with higher-risk work.

Retire stale skills when tool permissions change, the offer changes, approval policy changes, the team changes, a connector is replaced, or a scheduled job starts using the skill. Each skill should have a visible owner. If nobody owns it, do not let it control important work.

Common mistakes

• Too broad. A skill called "Sales Assistant" is not a skill. Split it into "Lead Reply Draft," "CRM Note Preparation," "Proposal Follow-Up Checklist."
• No approval gates. If a skill can send messages or change CRM status without stopping, the owner cannot review the output before it ships.
• Skills as memory. Durable preferences belong in memory, not in a procedure file. Mixing them makes the skill harder to inspect.
• Never tested. A skill that has not been run against a real example is a guess. Test before trusting.
• Never retired. Old skills become hidden bugs. Review them when the work, tools, or team changes.

Next step

Hermes skills work best for repeatable work with clear inputs, outputs, tools, and approval points. Keep them narrow, test with real examples, separate them from memory, and retire stale ones quickly. To set up the full worker that runs these skills, start with the private AI worker setup guide.

<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [
{
"@type": "Question",
"name": "What is a Hermes skill?",
"acceptedAnswer": {
"@type": "Answer",
"text": "A Hermes skill is a reusable, approval-gated procedure file that tells your AI assistant how to handle a specific type of repeated work. Each skill defines a purpose, inputs, allowed tools, blocked actions, approval gates, and an output format. When a task matches the skill's trigger conditions, Hermes loads it and follows the procedure instead of guessing from chat context."
}
},
{
"@type": "Question",
"name": "How do skills differ from runbooks?",
"acceptedAnswer": {
"@type": "Answer",
"text": "A runbook contains the business operating rules for a workflow — the policies and guardrails. A skill is the reusable procedure for a specific task inside that workflow — the concrete steps, tools, approvals, and output format. Runbooks define what should happen; skills define how Hermes should do it. Memory stores durable preferences, and project files track current state, so skills should not duplicate either."
}
}
]
}
</script>