Skills, Instructions, and Sharp Agents

Two Hermes agents can run the same model, have the same tools available, and live on the same machine — yet produce wildly different results. The difference is not the model. It is how clearly the agent is defined.

A vague agent with a general-purpose prompt and no boundaries will try to do everything. It will meander between tasks, produce inconsistent output, and require constant adjustment. A sharp agent with a narrow role, clear instructions, and the right tools will do one thing well — predictably and repeatedly.

In Chapter 8, you saw the agent loop: how an agent assembles context, calls the model, picks tools, and acts. The loop is the engine. But the engine needs steering — and that steering comes from four sources: the profile prompt, skills, memory, and project context. This chapter explains each source, how they differ, and how to combine them into agents that produce reliable results.

Sharp agents are built, not born. The work happens in the design.

Four layers

Where instructions come from

Every time the agent loop runs, the model receives instructions from multiple sources. These sources stack in a hierarchy — and understanding the hierarchy helps you decide where to put each piece of guidance.

Design principle

Narrow roles produce reliable output

The most common mistake in agent design is giving one agent too many responsibilities. A single "do everything" agent sounds convenient — until it tries to research keywords and draft content and publish articles in the same session, producing mediocre output on each task because its context is scattered.

A narrow role means three things: a single area of responsibility, a limited set of tools, and a clear boundary where this agent stops and another takes over.

In your SEO workflow, you already have two narrow roles from Chapter 3: the research specialist (find and filter keyword data) and the SEO manager (draft content and manage strategy). Each role does one thing well. The research specialist does not draft articles. The SEO manager does not run keyword searches. The boundary between them is clear: research produces data; the manager consumes that data and turns it into content.

Why does narrowness matter? Because every instruction, skill, and memory entry the agent loads competes for space in the model's context window. An agent with a focused role loads only the skills and memory relevant to that role. An agent with a broad role loads everything — and the model has to figure out which parts matter for the current task. Focused agents are faster, more consistent, and easier to debug when something goes wrong.

Procedures

Skills: reusable procedures that guide the loop

A skill is a document that tells the agent how to carry out a specific type of work. Skills are stored as SKILL.md files with YAML frontmatter at the top (name, description, version, tags) and a structured body below. The agent loads them automatically when the task matches — you do not need to manually activate a skill.

A good skill has three parts: a trigger (when to use it), a procedure (what to do), and an output contract (what the result should look like). Without a trigger, the agent might load the skill at the wrong time or not load it at all. Without a procedure, the agent improvises — which produces inconsistent results. Without an output contract, the agent might return data in a format the next step cannot consume.

Here is what a skill document looks like for the research specialist's keyword research procedure:

---
name: keyword-research
description: "Use when the user asks for keyword ideas, search volume data, or content topic research. Finds keywords, filters by relevance, and returns a structured list."
version: 1.0.0
author: you
metadata:
  hermes:
    tags: [seo, keywords, research]
---

# Keyword Research Procedure

## When to Use
- User asks for keyword ideas for a topic
- User wants search volume estimates
- User needs content topic suggestions

## Steps
1. Clarify the topic and target audience if not specified
2. Search for the core topic using the web search tool
3. Search for 2-3 long-tail variations
4. Collect all results into a single list
5. Filter: remove duplicates, remove irrelevant results
6. Score: rank by estimated relevance and competition level
7. Save the top results to a keyword file
8. Return a summary (top 5 only) to the user

## Output Contract
Return results as a structured list:
- Keyword (string)
- Estimated relevance (high/medium/low)
- Competition level (high/medium/low)
- Angle (brief description of the content angle)

Save full list to file. Return only top 5 in conversation.

The frontmatter (between the --- markers) tells the skill loader what this document is about. The body tells the agent what to do. Together, they give the agent enough structure to run the procedure without improvising.

Your SEO workflow

Writing procedures: research and content

Now let us apply the skill framework to both roles in your SEO team. In Chapter 8, you saw the research specialist run through the agent loop to find keywords. The specialist searched, filtered, and saved results — then waited for your review before the SEO manager started drafting.

That review step is a judgment gate — a point in the workflow where you decide whether the output is good enough to proceed. Skills make judgment gates possible because they define what "good enough" looks like. Without a skill, the research specialist might return raw search results and the SEO manager might try to draft from unstructured text. With skills, each agent knows its procedure and its output format.

Here is what the SEO manager's content brief skill looks like:

---
name: content-brief
description: "Use when the user wants a content brief or article outline based on keyword data. Reads keyword file, selects top keywords, drafts a structured brief."
version: 1.0.0
author: you
metadata:
  hermes:
    tags: [seo, content, brief, writing]
---

# Content Brief Procedure

## When to Use
- User asks for a content brief or article outline
- Keyword research is complete and saved to a file
- User approves the keyword selection

## Steps
1. Read the keyword file from the research specialist
2. Select the top 3-5 keywords for this content cycle
3. Draft a structured brief with:
   - Target keyword (primary)
   - Secondary keywords (supporting)
   - Proposed title
   - Content angle (1-2 sentences)
   - Word count range (e.g., 1500-2000 words)
   - Internal linking suggestions
4. Save the brief to a file
5. Return the brief to the user for review

## Output Contract
Return the brief as:
- Target keyword (string)
- Secondary keywords (list)
- Title (string)
- Angle (string)
- Word count range (string)
- Internal links (list of URLs or topics)

Do NOT publish. Wait for user approval.

Notice the last line of the output contract: Do NOT publish. Wait for user approval. This is a judgment gate encoded directly into the skill. The SEO manager will draft the brief and stop — it will not proceed to publishing because the skill explicitly forbids it. You review the brief, approve or request changes, and the manager proceeds only after your signal.

This is how skills, the approval system, and output contracts work together. The approval system catches dangerous actions (shell commands, file deletions). Skills catch process violations (publishing without review, skipping a step). Output contracts catch format problems (missing fields, wrong structure). Three layers of quality control — each checking a different dimension.

Tool access

Match tools to the role, not the agent

In Chapter 3, you saw that toolsets are enabled or disabled per profile. This is not just a security feature — it is a design tool. The tools available to an agent shape what the agent loop can do. If your research specialist has no web search toolset, it cannot research keywords — no matter how detailed the skill is. If your SEO manager has the shell execution toolset enabled, it might decide to run a publish script instead of waiting for your approval.

Tool matching means giving each profile only the toolsets it needs to fulfill its role — and nothing more. The research specialist needs web search (to find keywords), file writing (to save results), and file reading (to check prior research). It does not need the terminal toolset or the code execution toolset. The SEO manager needs file reading and writing (to draft briefs and content). It does not need web search — the research specialist provides the data.

This separation does two things. First, it prevents agents from accidentally stepping outside their role. A research specialist with no terminal access cannot run a publish command. Second, it helps the model make better tool selections. When the model sees a small, focused set of tools, it picks the right one more reliably than when it sees a long list of options it does not need.

Quality loops

Feedback loops: how agents get better over time

A sharp agent is not built in one pass. It starts as a reasonable design — narrow role, clear skill, matched tools — and gets sharper through feedback. There are three feedback mechanisms in Hermes:

These three mechanisms form a loop: the agent produces output, you review it, you give feedback, the agent incorporates the feedback into skills and memory, the next output is better. Over time, the agent gets sharper — not because the model changed, but because the instructions, procedures, and stored preferences accumulated through real use.

This is what "auto-learning" actually means in Hermes. It does not mean the agent independently discovers better approaches. It means the agent persists what you teach it — in skills (procedural corrections) and memory (preference updates). The agent follows instructions to save useful patterns; it does not improvise improvements on its own.

Your SEO workflow

Sharp agents, clear handoffs

Here is how the instruction hierarchy, role design, skills, tool matching, and feedback loops combine for your SEO team:

The model inside each profile is the same engine. The profile prompt, skills, memory, toolsets, and output contracts are the steering. Good steering produces sharp agents. Vague steering produces vague agents. The model does not change — the instructions do.