Hermes Agent Phase 3: Advanced Operations

"Phase 2 made your agent useful. Phase 3 makes it a production workhorse."

---

What You'll Learn in Phase 3

In Phase 2, you gave your agent memory, custom skills, and multi-platform access. Now we go deeper — into the operations that turn a personal agent into a production-grade automation platform.

By the end of this guide, you'll be able to:

• 🎛️ Configure any OpenAI-compatible model provider (local, private, or custom)
• ⏰ Schedule Hermes to run tasks automatically (cron jobs, recurring briefings, monitoring)
• 👥 Spin up parallel sub-agents for simultaneous multi-tasking
• 🛠️ Build custom tools that extend Hermes's capabilities
• 🔒 Set up multi-user access and permission controls

---

Part 1: Custom Model Provider Configurations

In Phase 1, you used the wizard (hermes model) to pick a provider. But Hermes supports any OpenAI-compatible API endpoint — including private servers, internal corporate models, and exotic open-weight deployments.

Manual Provider Configuration

hermes config set provider custom
hermes config set custom-api-base "https://your-server.com/v1"
hermes config set custom-api-key "sk-your-key"
hermes config set custom-model "your-model-name"

Provider Profiles

For teams or individuals who switch between multiple providers, Hermes supports named profiles:

hermes profile create work
hermes profile set work provider openai
hermes profile set work model gpt-5.6-sol

hermes profile create home
hermes profile set home provider custom
hermes profile set home custom-api-base "http://home-server:8000/v1"

hermes profile switch work   # Switch to work profile
hermes profile switch home   # Switch to home profile
hermes profile list          # List all profiles

Advanced: Router Configuration

For maximum flexibility, you can configure a router that directs different types of requests to different models:

# ~/.hermes/config.yaml (manual edit)
router:
  rules:
    - pattern: "write|compose|draft|essay"
      model: "claude-sonnet-5"
      provider: "anthropic"
    - pattern: "code|debug|refactor|test"
      model: "gpt-5.6-terra"
      provider: "openai"
    - pattern: "search|browse|research"
      model: "gpt-5.6-luna"
      provider: "openai"
    - pattern: ".*"
      model: "hermes-3-12b"
      provider: "local"

This is a pattern-based router: every prompt is matched against regex patterns, and the request is routed to the optimal model/provider. Your cheapest/fastest model acts as the catch-all.

Why this matters: With router config, you can use GPT-5.6 Sol ($0.15/M tokens) only for complex reasoning, Claude for writing, and a local model for everything else — optimizing for both cost and quality.

---

Part 2: Cron Automation — Your Agent on a Schedule

Hermes Agent has a built-in cron scheduler that lets you run agent tasks on a recurring schedule. No external cron daemon needed.

Basic Cron Jobs

# Run a prompt every morning at 8AM
hermes cron add \
  --name "morning-briefing" \
  --schedule "0 8 * * *" \
  --prompt "Search the web for today's top AI news and summarize in 5 bullet points. Save to ~/briefings/$(date +%Y-%m-%d).md"

# Run every hour
hermes cron add \
  --name "hourly-health" \
  --schedule "0 * * * *" \
  --prompt "Check the status of my server processes and report any anomalies."

Cron Schedule Format

Standard cron syntax (minute hour day month weekday):

* * * * *      → Every minute
0 * * * *      → Every hour (at :00)
0 8 * * *      → Every day at 8:00 AM
0 8 * * 1-5    → Weekdays at 8:00 AM
0 0 1 * *      → First day of every month
*/15 * * * *   → Every 15 minutes

Managing Cron Jobs

hermes cron list              # List all scheduled jobs
hermes cron logs --name "morning-briefing"  # View job execution history
hermes cron remove --name "morning-briefing"  # Delete a job
hermes cron pause --name "hourly-health"     # Pause without deleting
hermes cron resume --name "hourly-health"    # Resume a paused job

Practical Cron Use Cases

Use Case	Schedule	Prompt
Daily news briefing	0 8 * * *	"Summarize top 5 AI news stories. Save to briefings/today.md"
Weekly blog post	0 9 * * 1	"Write a 1500-word blog post about {{topic from config}}. Save to ~/blog/drafts/"
GitHub PR review	30 */4 * * *	"Check my GitHub notifications. Summarize any pending PR reviews."
Stock price alert	0 9,13,16 * * 1-5	"Check SKHY stock price. If down >5% from IPO price, alert me via gateway."
Server disk usage	0 6 * * *	"Run df -h and alert me if any partition is >85% full."
Weekly competitor monitoring	0 10 * * 1	"Check 3 competitor sites for new features or content changes. Summarize differences."

Pro tip: Each cron job runs in a fresh agent session with full access to memory and skills. Your agent remembers context from previous runs, so daily briefings get more personalized over time.

---

Part 3: Parallel Sub-Agents — Doing Multiple Things at Once

By default, Hermes processes one request at a time. But with sub-agents, you can spin up multiple agents to work in parallel — each with its own task, model, and tool set.

Spawning a Sub-Agent

hermes agent spawn --task "Research NVIDIA's latest GPU announcement"

This creates a child agent that runs independently. The parent agent can continue working while the child completes its task.

Advanced Sub-Agent Configuration

# Spawn with specific model and tools
hermes agent spawn \
  --task "Write a Python script to parse this CSV data" \
  --model "gpt-5.6-terra" \
  --tools "code,file" \
  --timeout 120

# Spawn asynchronously (fire-and-forget)
hermes agent spawn --async \
  --task "Download and summarize the latest arXiv papers on RLHF" \
  --output "~/research/rlhf-summary.md"

Collective Tasks

For complex workflows, you can define a collective — a group of sub-agents that work together:

hermes collective create --name "market-research"
hermes collective add-agent --name "analyst-1" --task "Analyze SK Hynix Q2 earnings transcript"
hermes collective add-agent --name "analyst-2" --task "Research HBM market share trends 2026"
hermes collective add-agent --name "analyst-3" --task "Compile competitor pricing data (Micron, Samsung)"
hermes collective run

Each agent works independently. When all are done, Hermes presents a merged report with findings from all sub-agents.

Sub-Agent Commands

hermes agent list                  # List active sub-agents
hermes agent status --id <id>      # Check specific sub-agent
hermes agent cancel --id <id>      # Cancel a running sub-agent
hermes agent output --id <id>      # Get sub-agent's output
hermes collective list             # List defined collectives
hermes collective run --name "..." # Run a collective

When to Use Sub-Agents vs. Sequential Processing

Scenario	Approach	Why
Research multiple topics	Sub-agents (parallel)	3x faster than sequential
Multi-file code review	Sub-agents (parallel)	Each file reviewed independently
Weekly blog writing	Sequential	Needs creative flow
Complex debugging	Sequential	Context chains between steps
Competitor analysis	Sub-agents (parallel)	Each competitor analyzed separately

---

Part 4: Building Custom Tools

Hermes ships with 40+ built-in tools, but occasionally you need something specific. Hermes lets you create custom tools using a simple YAML + Python format.

Tool Architecture

Every Hermes tool has three components:

1. A YAML manifest — defines the tool's name, description, parameters
2. A Python/Shell handler — the actual implementation
3. A permission policy — what the tool can access

Creating a "Trending GitHub Repos" Tool

Let's build a custom tool that fetches trending GitHub repositories.

Step 1: Create the manifest

hermes tools create --name "github-trending"

This creates ~/.hermes/tools/github-trending/tool.yaml:

name: github-trending
description: "Fetch trending GitHub repositories by language"
version: 1.0
parameters:
  language:
    type: string
    description: "Programming language filter (e.g., python, typescript)"
    required: false
  since:
    type: string
    description: "Time range: daily, weekly, monthly"
    enum: ["daily", "weekly", "monthly"]
    default: "daily"
  max_results:
    type: integer
    description: "Maximum repos to return"
    default: 10

Step 2: Create the handler

~/.hermes/tools/github-trending/handler.py:

#!/usr/bin/env python3
import requests
import json
import sys

def run(params):
    language = params.get("language", "")
    since = params.get("since", "daily")
    max_results = params.get("max_results", 10)
    
    url = f"https://github.com/trending/{language}?since={since}"
    headers = {"User-Agent": "Hermes-Agent/1.0"}
    
    # Simpler approach: use GitHub's search API
    query = "stars:>1000"
    if language:
        query += f" language:{language}"
    
    api_url = f"https://api.github.com/search/repositories?q={query}&sort=stars&order=desc&per_page={max_results}"
    resp = requests.get(api_url, headers=headers)
    
    if resp.status_code != 200:
        return {"error": f"GitHub API returned {resp.status_code}"}
    
    repos = resp.json().get("items", [])
    return [
        {
            "name": repo["full_name"],
            "stars": repo["stargazers_count"],
            "description": repo["description"][:120] if repo["description"] else "",
            "url": repo["html_url"],
            "language": repo["language"],
        }
        for repo in repos
    ]

if __name__ == "__main__":
    params = json.loads(sys.argv[1]) if len(sys.argv) > 1 else {}
    result = run(params)
    print(json.dumps(result, indent=2))

Step 3: Test it

hermes tools test github-trending --params '{"language": "python", "since": "weekly", "max_results": 5}'

Step 4: Use it in conversation

You: What's trending in AI on GitHub this week?

Hermes: Let me check...
        (runs github-trending tool with language="ai")
        
        Here are the top trending AI repos this week:
        1. NousResearch/hermes-agent — 17,400 stars
        2. microsoft/flint — 4,200 stars
        3. TencentCloud/tencentdb-agent-memory — 2,800 stars

Tool Permission Model

Each tool has a permission level that controls what it can access:

# In tool.yaml
permissions:
  network: true         # Can make HTTP requests
  filesystem: read      # read, write, or none
  execution: false      # Can run shell commands
  environment: []       # Env vars the tool can read

Permission	Values	Description
network	true/false	Internet access
filesystem	none, read, write	File system access level
execution	true/false	Shell command execution
environment	List of var names	Which env vars are readable

Security note: Tools run in a sandboxed environment with network and filesystem access controlled by their permission model. A tool with network: true, filesystem: none, execution: false cannot read your files or run commands — it can only make API calls.

Installing Community Tools

Hermes has a tools registry where the community shares custom tools:

hermes tools search "notion"     # Search registry for Notion tools
hermes tools install "notion-api"  # Install from registry
hermes tools publish              # Publish your tool to the registry

---

Part 5: Multi-User Access & Permissions

If you're running Hermes as a team agent, you'll want to control who can do what.

Creating Users

hermes user add --name "alice" --role "editor"
hermes user add --name "bob" --role "viewer"
hermes user add --name "carol" --role "admin"

Role-Based Access

Role	Permissions
admin	Full access — all commands, all config, all tools
editor	Can chat, use tools, create skills — cannot change system config
viewer	Can chat — cannot modify any config or create skills
custom	Define per-user permissions

Custom Roles

hermes role create "analyst" \
  --allow "chat, tools, cron" \
  --deny "config, users, skills"

Session Limits

hermes config set max-concurrent-sessions 5
hermes config set session-timeout-minutes 30
hermes config set max-tokens-per-session 500000

---

Phase 3 Quick Reference

Custom Models

hermes config set provider custom
hermes config set custom-api-base <url>
hermes config set custom-model <name>
hermes profile create <name>
hermes profile switch <name>

Cron Automation

hermes cron add --name "<name>" --schedule "<cron>" --prompt "<text>"
hermes cron list
hermes cron logs --name "<name>"
hermes cron remove --name "<name>"

Sub-Agents

hermes agent spawn --task "<task>"
hermes agent list
hermes agent cancel --id <id>
hermes collective create --name "<name>"
hermes collective run --name "<name>"

Custom Tools

hermes tools create --name "<name>"
hermes tools test <name> --params '<json>'
hermes tools search "<query>"
hermes tools install "<name>"
hermes tools list

---

Troubleshooting Phase 3

Cron Job Not Running

# Check if the cron scheduler is running
hermes cron status

# Start it if needed
hermes cron start

# Check job logs
hermes cron logs --name "job-name" --tail 20

Sub-Agent Timed Out

# Increase timeout for complex tasks
hermes agent spawn --timeout 300 --task "..."

# Check available system resources
free -h

Custom Tool Not Found

# Reindex all tools
hermes tools reindex

# Verify tool files exist
ls -la ~/.hermes/tools/<tool-name>/

# Check YAML syntax
hermes tools validate <tool-name>

Router Not Working

# Test routing
hermes router test --prompt "Write an essay about AI"

# Reload router config
hermes router reload

# Disable router (fall back to default model)
hermes config set router-enabled false

---

What's Next: Phase 4 Preview

You've now transformed your agent from a conversational tool into an automation platform. Custom routing, scheduled tasks, parallel agents, and custom tools are the difference between "fun experiment" and "serious infrastructure."

Phase	Title	Status
🟢 Phase 1	Beginner's Guide — Install, configure, first conversation	✅ Complete
🟡 Phase 2	Memory, Skills & Gateway	✅ Complete
🟠 Phase 3	Advanced Operations — Custom models, cron, sub-agents, tools	✅ Complete
🔴 Phase 4	The Master Level — RL training, trajectory generation, fine-tuning	📅 Next

Your mission for Phase 3:

1. Set up at least one cron job (try the daily news briefing)
2. Run a collective of 3 sub-agents on a research task
3. Create one custom tool that solves a real problem you have
4. If using Hermes with a team, set up multi-user access

Ready for the final level? Phase 4: The Master Level covers RL training on your own agent trajectories, generating synthetic training data, and fine-tuning custom agent models.

---

Series accuracy: This guide reflects Hermes Agent latest stable release as of July 10, 2026.