The Skills Ecosystem: Architecture and Philosophy

Why Agent Knowledge Has a Loading Problem

Imagine loading every book in a library into your working memory before answering a question. That is the naive approach to agent knowledge — store everything in the system prompt and hope it fits. It does not scale. A capable agent working on real projects accumulates hundreds of procedures, workflows, and tool-specific techniques. Loading all of them for every conversation wastes tokens, degrades reasoning quality, and quickly exceeds context limits.

Hermes solves this with a progressive loading architecture built on a simple insight: most knowledge is needed some of the time, not all of the time. The Skills system is the implementation of that insight. Skills are on-demand knowledge documents — procedures the agent can retrieve when they become relevant and ignore when they are not. Understanding this architecture at a conceptual level is what separates developers who merely use skills from those who design them well.

Three Layers of Agent State: Prompts, Memory, and Skills

Hermes maintains three distinct layers of agent state, each with a different loading pattern and purpose.

Prompts are always present. They define the agent's core identity, base behaviors, and the immediate task. Everything in the system prompt costs tokens on every single turn, so this layer stays small and general.

Memory is also always present, but it is composed of small, durable facts the agent has learned about you, your environment, and your preferences. A memory might record your preferred code style, your server hostname, or the fact that you work in a monorepo. Memories are short — they need to fit in context without crowding out the task. They are never procedures.

Skills are on-demand. They contain procedures — numbered steps, known pitfalls, verification approaches, and supporting reference files. A skill might describe exactly how to set up a new microservice in your stack, how to run the security scanner before a release, or how to submit a pull request following your team's conventions. Skills load only when the agent decides they are relevant. That decision happens through a three-level progressive disclosure system, which you will explore in depth in Lesson 4.

The practical takeaway: if something belongs in every conversation, it is a memory. If it belongs in some conversations and can be retrieved on demand, it is a skill.

The Five Components of the Hermes Skills Ecosystem

The Skills ecosystem is not one feature — it is five interconnected systems that together make skills useful at scale.

SKILL.md is the file format at the center of everything. Every skill is a directory containing at minimum one SKILL.md file with YAML frontmatter and a structured body. The format follows the agentskills.io open standard, which means SKILL.md files are portable across any agent that implements the standard.

/learn is the command that creates skills. Instead of writing SKILL.md files by hand, you can point Hermes at a directory, a documentation URL, a workflow you just walked through, or pasted notes — and the agent authors the skill for you. /learn is the primary way most skills get created in practice.

The Skills Hub is a 672-skill registry connecting to multiple sources: GitHub repositories, the skills.sh marketplace, ClawHub, and LobeHub. Hub skills go through a security scan before installation. This is where you find community-authored skills for common tools and workflows.

The Curator is the automated lifecycle manager. It runs on a configurable interval (default: every 7 days) and moves skills that have gone unused through the lifecycle from active to stale to archived. The curator keeps your library clean without requiring manual intervention.

Bundles group multiple skills under a single slash command. A bundle called backend-dev might load three skills simultaneously — code review, test-driven development, and pull request workflow — turning a complex multi-skill workflow into a single invocation.

These five components form a closed loop. You create skills via /learn or by hand, discover community skills through the Hub, invoke them individually or via bundles, and the curator keeps the library healthy over time.

How the Agent Decides to Load a Skill

Understanding the agent's skill loading decision helps you design better skills. The process works in three stages.

At the start of every session, Hermes scans the Level 0 metadata of all installed skills. This scan returns roughly 3,000 tokens of data — just the name, description, and category of each skill. The agent uses this metadata to maintain a mental map of what procedures are available.

When a task arrives, the agent evaluates whether any installed skill is relevant. This is why skill descriptions need to be precise. A description like "helps with git" tells the agent almost nothing about when to load the skill. A description like "submit a pull request following team conventions" gives the agent enough signal to recognize that this skill belongs in a code review context.

When relevance is determined, the agent fetches Level 1 — the full skill content. For complex procedures with supporting reference files, it can go to Level 2 to retrieve those files separately, keeping the main SKILL.md focused.

The Self-Improvement Loop: Skills as Procedural Memory

Skills become most powerful when they accumulate over time. Every complex task Hermes successfully completes is a candidate for a new skill. Every error encountered and fixed is a candidate for a Pitfalls entry. The agent can create skills autonomously after completing workflows — this is what Hermes calls the self-improvement loop.

The loop works like this: you give the agent a complex, multi-step task. It completes the task. It recognizes that the procedure it followed could be useful again. Using the skill_manage tool, it creates a SKILL.md capturing what it did, the pitfalls it encountered, and how it verified success. Next time a similar task arrives, the skill is waiting.

This is also why the write approval gate exists. Autonomous skill creation is powerful, but you may want to review what the agent chooses to remember. Lesson 10 covers the approval gate in full.

The agentskills.io Open Standard

Hermes implements the agentskills.io open standard for skill format and discovery. The standard defines the SKILL.md file structure, the frontmatter schema, and the progressive disclosure loading protocol.

What this means in practice: skills you author for Hermes are portable. If you switch to another agent that implements the same standard, your skills move with you. Community skills published to GitHub or the skills.sh marketplace can be consumed by any compliant agent.

The standard also means the Skills Hub is not Hermes-specific infrastructure — it is an open registry. Skills from OpenAI, Anthropic, Hugging Face, and NVIDIA are available through their respective trusted taps, and community contributors can publish to the public registries without going through Nous Research. This openness is what makes 672 skills available at install time rather than a curated few.