Self-Improving Skill Pipeline with Hermes Learning Loop

Hermes Agent v2.0+ uses its built-in learning loop to autonomously create, improve, and distribute reusable skills from repeated task execution. When the agent notices a task pattern recurring across sessions, it captures the workflow steps, tool calls, decision points, and output format into a SKILL.md file stored in the skills directory. Over subsequent runs, the agent self-improves each skill by analyzing execution logs, detecting friction points like repeated error retries or unnecessary tool calls, and rewriting the skill instructions to eliminate those patterns. The agentic reasoning step involves the agent comparing execution traces across skill invocations, identifying variance in output quality, and deciding whether the skill needs refinement, the SOUL.md personality needs adjustment, or the user's intent has drifted from the original skill design. Measurable outcome: skills improve 30-40% in execution efficiency over 4 weeks of use, measured by reduction in tool calls per task and user correction rate.

BUSINESS PROBLEM

A solo founder building a SaaS product runs 15-20 repetitive workflows per week: generating release notes, triaging customer emails, creating social media posts, running competitor analysis, updating CRM records, and generating weekly NPS reports. Each workflow requires 20-45 minutes of manual setup, context loading, and prompt engineering. Over a month, the founder spends 25+ hours on tasks that follow identical patterns each time, but different enough that simple automation scripts cannot handle the slight variations in input and desired output. [ STAT ] Knowledge workers spend 60% of their week on repetitive digital tasks that could be automated, with the average professional executing the same 10 workflows 20+ times per month without realizing they are repeating identical patterns. — McKinsey Automation Report, 2025. The founder needs an agent that recognizes these patterns automatically and encodes them into reusable skills that get faster and more accurate with each use, without requiring any manual scripting or automation configuration beyond normal usage.

WHO BENEFITS

1. Solo founders and indie hackers who wear 10 hats daily and need an agent that encodes their recurring workflows into reusable skills without requiring them to write any automation code or documentation — the agent learns by watching and improves with each repetition across their entire work week. 2. Operations managers at agencies serving 20+ clients who run repeated analysis and reporting workflows with client-specific variations and need a skill system that handles parametric inputs (client name, metric range, date window) while keeping the core workflow structure consistent across all client deliverables. 3. Technical team leads who maintain a shared skills repository for their engineering team and want the agent to automatically detect when a skill has become outdated due to API changes or workflow improvements, then suggest or apply updates with documented change rationale for team review.

HOW IT WORKS

1. [TOOL: Hermes Agent v2.0+] Pattern detection: Hermes monitors session activity across conversations. When it detects the same sequence of tool calls appearing 3 times across sessions (e.g., web search for competitor news, extract from 5 URLs, format as markdown brief, send to Telegram), it flags the sequence as a skill candidate. Input: session tool call logs from SQLite state database. Output: candidate skill definition with detected steps, tool names, and output format. 2. [TOOL: Hermes Skills System] Skill creation: Hermes generates a SKILL.md file in the skills directory with instruction steps, expected inputs, output format, tool requirements, and error handling guidance. The agent writes the skill description in the standard agentskills.io compatible format. Input: detected pattern. Output: executable SKILL.md file with frontmatter and step-by-step instructions. 3. [TOOL: Hermes Agent v2.0+] Skill invocation: on subsequent sessions, when the agent recognizes a user request matching a skill description, it loads the SKILL.md into context and executes the workflow. The agent logs each tool call, its duration, its result status, and any user corrections made during execution. Input: user prompt + matched skill. Output: execution trace with timestamps and status per step. 4. [TOOL: Hermes Agent v2.0+] Self-improvement trigger: after every 5 invocations of a skill, or when the user manually runs /skills improve <skill-name>, Hermes analyzes the execution traces. This is the AI reasoning/decision point: the agent compares execution paths across invocations, identifies steps where the user frequently corrected the output, measures step completion time variance, and decides whether the step needs reordering, additional guardrails, or complete replacement with a different tool chain. 5. [TOOL: Hermes Skills System] Skill rewrite: the agent generates a new version of the SKILL.md with specific improvements: it adds context validation steps where users corrected inputs, it removes redundant tool calls that never added value, it inserts error recovery steps for failures that occurred in 2+ executions. Input: improvement analysis. Output: updated SKILL.md with version increment in frontmatter. 6. Human Review: Hermes presents a diff of the skill changes via the gateway with an Accept/Rollback prompt. If no response within 24 hours, the agent logs the improvement as Pending and continues using the previous version. 7. [TOOL: GitHub MCP Server] Distribution: for shared skills, Hermes opens a pull request on the team's skills repository with the updated SKILL.md, a summary of changes, and execution improvement metrics. The PR assigns the team lead as reviewer. Input: improved skill file. Output: GitHub PR with changelog. 8. [TOOL: Hermes Agent v2.0+] Learning loop closure: the agent updates its user model (Honcho dialectic model) with the skill improvement outcome, so future skill suggestions factor in which improvement types were accepted or rejected by this user. Input: user acceptance or rejection. Output: updated user model stored in Honcho profile.

TOOL INTEGRATION

Hermes Agent v2.0+: Install and configure with a profile that has skills enabled. The learning loop is on by default. Configure skill auto-creation threshold with hermes config set skill.pattern_min_count 3 (default). Gotcha: the pattern detection runs as a background task every 10 sessions. If sessions are short (under 5 tool calls), the detector may never trigger. Ensure sessions have enough depth by avoiding overly narrow task scope. Hermes Skills System: Skills are stored in ~/.hermes/skills/ as SKILL.md files with YAML frontmatter. The agent loads skills on session start based on fuzzy-matched user intent. Skills from agentskills.io are compatible. Gotcha: skill frontmatter that defines required_tools but the user has not configured those tools will silently fail at invocation time. Add a pre-flight check step in the skill that verifies tool availability before execution begins. SQLite Memory Store: Hermes uses SQLite for session logs, execution traces, and the user model. The database lives at ~/.hermes/state.db. For teams, this can be pointed at a shared Postgres instance via hermes config set state.db_url. Gotcha: SQLite does not support concurrent writes from multiple Hermes instances. If running multiple profiles simultaneously on the same host, configure each profile with a separate state database path. Nous Portal / OpenRouter: Hermes supports 200+ models through these providers. For skill generation, Opus-class models produce better workflow instructions. For skill execution, Sonnet-class models are sufficient. Configure per-skill model overrides in the skill frontmatter with preferred_model: anthropic/claude-sonnet-4.6. GitHub MCP Server: Used for skill distribution. Requires a token with contents:write PR scope. Gotcha: if the skills repository has branch protection rules requiring linear history, configure the MCP server to create merge commits rather than squash merges via the mcp_github.create_pull_request merge_method parameter.

ROI METRICS

1. Time to encode a new skill: Before N/A (no skill system — each task done from scratch) → After 3-5 automatic detections before a skill candidate is created, then 0 minutes of manual effort for skill authoring. 2. Skill execution time improvement over 4 weeks: After 30-40% reduction in tool calls and 25% reduction in wall-clock time per skill invocation, measured by agent execution trace analysis. 3. User correction rate per skill invocation: After Week 1: 18% of invocations require user correction → After Week 4: 4% require correction, measured as number of /undo or manual edits per skill run. 4. Skill coverage of daily tasks: After Week 1: 3-5 skills covering 20% of recurring tasks → After Week 8: 15-20 skills covering 70% of repeated workflows, tracked via skill invocation count vs total session count. 5. Hours saved per week in repeated workflow execution: After 4 weeks: 8-12 hours saved across all skill-enabled workflows, measured by comparing skill-execution duration to estimated manual execution duration based on pre-skill session logs.

CAVEATS

1. Pattern detection false positives: The agent may detect patterns in coincidentally similar tool call sequences that do not represent a true reusable workflow. Set skill.pattern_min_count higher (5-7) for production use to reduce noise, and review skill candidates weekly. 2. Skill improvement over-correction: The self-improvement loop can over-optimize for a single execution trace at the expense of general applicability. Set skill.max_improvements_per_day to 2 and require human approval for every 5th improvement cycle. 3. Skill files accumulate indefinitely: Hermes does not auto-delete skills. After 6 months of use, a profile may have 100+ skills, many of which are for workflows no longer relevant because the user's job function or tool chain has changed. Schedule a quarterly skill audit where the agent reviews all skills and suggests archival candidates based on low-invocation frequency over the last 60 days. 4. OpenRouter model variability: If using OpenRouter for skill execution, model availability changes can break skills that depend on specific model capabilities. Pin the model in each skill's frontmatter preferred_model field and add a fallback model in fallback_model.