Hermes Skills, Models & Automation: Make Your Agent Actually Useful
The difference between an agent you use and one you rely on: reusable skills, deliberate model choice, and scheduled tasks that deliver results while you sleep.
Beginner9 min read
What you'll be able to do by the end
- Understand what skills are and how the agent learns your routines
- Choose models on purpose instead of by default
- Build a workflow you reuse weekly
- Schedule recurring tasks that deliver results to Telegram
Before you start
- A working Hermes installation (see our setup guide)
- Comfort with basic sessions and commands from the beginners article
By now you can drive the agent. This article makes it worth driving daily — the layer where Hermes stops being a clever tool and becomes infrastructure: skills that remember your procedures, model choice that balances quality against cost, and scheduled automation that produces results without you in the room.
Skills: teaching once, reusing forever
A skill is a written procedure the agent loads exactly when it’s relevant — your deployment steps, your report format, your research method. Three things make them powerful:
They’re already there. Bundled skills ship with Hermes (~90 of them) and more install from the Skills Hub. Type / in a session and scroll — each installed skill is also a slash command.
The agent writes its own. After a good working session, say “save this as a skill.” It authors the document, files it properly, and loads it next time the situation matches.
They teach from sources too. Point /learn at documentation, meeting notes, or a full book: it builds a knowledge-base skill — core ideas upfront, details loaded only when a question needs them.
The practical effect: your second time through any complex task costs a sentence instead of an explanation.
Choosing models like an adult
hermes model shows providers; switching is instant and non-destructive. Deliberate selection looks like this:
| Task | Fit | Why |
|---|---|---|
| Hard analysis, architecture, debugging | Strongest reasoning model you can afford | Errors compound downstream |
| Bulk summaries, classification, quick lookups | Fast/cheap model | Quality gap barely visible; speed and cost win |
| Private/sensitive material | Local model via Ollama/llama.cpp | Nothing leaves your machine |
| Everything, minimal management | Subscription login (e.g. Nous Portal) | Hundreds of models, one account |
The 64K-context minimum applies everywhere. Beyond that, don’t romanticize: most people do best on a subscription or one API key, adjusting upward only when a task genuinely needs more brain.
Workflows: prompts that graduated
A workflow is a prompt that survived contact with reality. Build one:
- Run the task manually — “review this folder, note what changed since Friday, draft status notes in my tone.”
- Refine the wording until output is reliably good — tighten scope, add constraints.
- Save it: “save this as a skill called weekly-status.”
- Invoke forever:
/weekly-status— later maybe/weekly-statuson a schedule.
That ladder — manual → refined → saved → scheduled — is the whole craft. Each step is plain language; none involves code.
Scheduling: the agent works while you don’t
Natural language is the interface:
Every morning at 9am, check Hacker News for AI news and send me a summary on Telegram.
Hermes creates the job internally. Under the hood you get scheduling formats from every 2h to full cron expressions, skills attached to jobs, delivery to any connected platform, and jobs you pause, edit, or remove by asking. Results land in the chat you named — often the Telegram connection from the previous article.
Two safety rails come standard: pre-flight validation warns you once about broken configuration without spending tokens, and cron sessions can’t spawn more cron sessions — no runaway loops.
A realistic starter stack
For a solo professional running Hermes locally:
- Daily: morning briefing job → Telegram (“check these three pages, summarize changes”).
- Weekly:
/weekly-statusskill over your project folders. - On demand: research briefs, document triage, file cleanup.
- Model: default subscription model; escalate per-task when analysis gets heavy.
Total setup effort: an afternoon. Ongoing effort: reading the results — which was always the point.
Where this series ends — and yours begins
Start with What Is Hermes Agent? if you haven’t; install via the Desktop guide; learn the controls in Beginners; carry it in Telegram; and let this article make it permanent. Five articles, one afternoon each — and a working AI agent woven into your actual week.
Steps
Step 1: Understand skills: procedures the agent remembers
A skill is a knowledge document the agent loads only when relevant — instructions for 'how we do X here'. Hermes ships with dozens of bundled skills, installs more from the Skills Hub, and writes new ones itself when a session taught it something worth keeping. Ask it directly: "What skills do you have?" — or type / in a session to see them as slash commands.
Note: Skills load on demand, so having many installed doesn't bloat every conversation. They cost nothing until needed.
Step 2: Teach it your routine once
When you finish any multi-step task worth repeating, tell Hermes: "Save what we just did as a skill." Next time, invoke it with /skill-name plus your specifics. This is the closest thing to hiring someone who never forgets a procedure.
Note: You can also point /learn at documentation, notes, or a whole book — it builds a knowledge-base skill you can question later.
Step 3: Pick models deliberately
`hermes model` switches provider and model anytime — no lock-in. The beginner-friendly logic: strong reasoning models for hard analysis; fast cheap models for bulk summarizing and simple lookups; local models for privacy-sensitive work. One subscription login (Nous Portal) covers hundreds of models if you'd rather not manage keys at all.
Note: Switching mid-project is safe — context carries over. Match the model to the task's difficulty, not to habit.
Step 4: Build your first reusable workflow
Combine a prompt pattern + a skill into something you run weekly: "Every Monday morning, review my project folder, list what changed last week, and draft status notes in my voice." Run it manually a few times, refine the wording until output is consistently good, then save it as a skill — now it's a procedure, not a lucky prompt.
Note: Name workflows after outcomes ('weekly-status'), not tools. You'll reuse them more.
Step 5: Automate with natural-language scheduling
Say it plainly: "Every day at 9am, check this page for changes and send me a summary on Telegram" — Hermes creates a scheduled job internally. Or use /cron in chat: /cron add "every 2h" "Check server status". Jobs can attach skills, deliver results to any connected platform, pause, resume, and be edited without recreating.
Note: Scheduled jobs run even when you're not in a conversation — results arrive where you told them to go.
Step 6: Keep automation honest
Three guardrails for unattended work: give jobs clear scope ('check this page', not 'watch everything'); require approval for anything destructive even on schedule; and review outputs the first week like a manager reviewing a new hire. When a job misbehaves, edit its prompt — no code required.
Note: Cron-run sessions can't create more cron jobs — a built-in guard against runaway scheduling loops.
Common mistakes — and how to avoid them
MistakeInstalling fifty skills because they exist.
Do this insteadKeep the handful you actually invoke; browse the hub when a real need appears. Skills are tools, not trophies.
MistakeUsing the strongest (most expensive) model for everything.
Do this insteadMatch model to task difficulty. Bulk summaries on a fast model cost pennies and finish sooner.
MistakeScheduling a vague task like 'keep me informed'.
Do this insteadScope jobs precisely: which source, which action, where to deliver. Vague schedules produce noise you'll mute.
MistakeNever reviewing automated output after week one.
Do this insteadSpot-check periodically. Automation drifts when sources change — a two-minute review keeps it trustworthy.
❓ Frequently asked questions
Do I need to write code to create a skill?
No. The fastest path is telling Hermes what you did and asking it to save it as a skill — it authors the file itself. You can also use /learn to build skills from docs, notes, or entire books, again without writing anything.
Which model should a beginner start with?
Whatever your easiest path gives you: a subscription login covers many models behind one account, so start with the default recommendation and adjust when you notice tasks outgrowing it. The requirement is simply a model with at least 64K tokens of context.
Where do scheduled results go?
Wherever you say: back to the chat that created the job, to Telegram, Discord, email, or other connected platforms. Delivery is part of the job definition, changeable anytime.
Can scheduled jobs run when my computer is off?
No — jobs fire when Hermes runs. For always-on automation, host Hermes on a machine that stays up: a home server, mini PC, or cloud instance. Many people start on their laptop and move later.
How is this different from Zapier-style automation?
Zapier connects predefined apps with predefined triggers. An agent reads, reasons, and acts across anything your machine can reach — including cases nobody built a connector for. The trade-off: you review its judgment rather than audit fixed rules.