The skills system is what separates Hermes Agent from every other AI agent. While most agents re-derive how to do everything from scratch on every request, Hermes builds a persistent library of reusable code that executes instantly. This guide covers everything you need to know about skills: how they work, the 74+ built-in skills, how to build custom ones, and how to share and profit from your skill library.
What Are Hermes Skills?
A Hermes skill is a Python file that encapsulates a specific capability. When you ask Hermes to do something new that it doesn't have a skill for, it:
- Breaks down the task into executable steps
- Writes Python code to accomplish those steps
- Tests the code
- If successful, saves it as a
.pyskill file with metadata - Registers the skill in the SQLite database
The next time you ask for something similar, Hermes:
- Recognizes the task type
- Looks up the relevant skill in the database
- Executes the pre-written code directly
- Returns results significantly faster and cheaper than re-generating
Over weeks and months, your skill library becomes a custom software toolkit perfectly tuned to your workflows. This is the compounding intelligence effect — Hermes in month 6 is dramatically more capable and cost-effective than Hermes in month 1.
The 74+ Built-In Skills
Hermes ships with a substantial library of pre-built skills organized into categories:
Research and Information Skills
web_search: Search the web and return structured results with titles, URLs, and snippets. Parameters: query, num_results, date_filter.
youtube_transcript: Extract the full transcript from any YouTube video URL. Returns timestamped text for analysis, summarization, or content extraction.
reddit_search: Search Reddit threads and comments. Returns post content, comment trees, and metadata. Useful for community sentiment analysis.
news_monitor: Fetch recent news on a topic from multiple sources. Returns headlines, summaries, and source URLs.
webpage_extract: Extract clean text content from any URL, stripping navigation and ads. Returns markdown-formatted content.
academic_search: Search academic papers via Semantic Scholar and similar APIs. Returns titles, abstracts, authors, and citation counts.
Content Creation Skills
article_writer: Given a topic and brief, produces a structured long-form article. Parameters: topic, word_count, target_keyword, tone.
social_post_generator: Creates platform-optimized social media posts. Parameters: content_brief, platform (twitter/linkedin/instagram), style.
email_composer: Drafts professional emails given context and intent. Parameters: recipient_role, email_purpose, tone, key_points.
script_writer: Generates video scripts with hooks, main content, and calls to action. Parameters: topic, duration_minutes, style.
seo_optimizer: Analyzes and optimizes content for a target keyword. Returns suggestions for title, meta description, headings, and internal links.
Data Analysis Skills
csv_analyzer: Loads and analyzes a CSV file. Returns descriptive statistics, column summaries, and highlighted anomalies.
chart_generator: Creates charts and graphs from data. Supports bar, line, scatter, pie charts using matplotlib. Saves as PNG.
data_cleaner: Standardizes and cleans messy datasets. Handles missing values, duplicate removal, type conversion.
market_research: Compiles competitive intelligence on a topic or product. Aggregates data from multiple sources.
sentiment_analyzer: Analyzes text sentiment at document or sentence level. Returns positive/negative/neutral scores.
File Management Skills
file_organizer: Organizes files in a directory by type, date, or custom rules.
pdf_extractor: Extracts text and structure from PDF files. Preserves formatting and page structure.
batch_renamer: Renames multiple files according to a pattern. Supports regex and date-based renaming.
file_converter: Converts between file formats. Supports text, CSV, JSON, Excel, and more.
Automation Skills
webhook_handler: Sets up and processes incoming webhooks. Parses payload and triggers actions.
api_connector: Makes authenticated API calls to any REST API. Handles authentication, pagination, and error handling.
scheduler: Sets up scheduled task execution. Supports cron-style scheduling.
form_filler: Fills out web forms programmatically. Requires field mapping configuration.
Communication Skills
telegram_sender: Sends messages, files, and images to Telegram chats or channels.
email_sender: Sends emails via SMTP or Gmail API.
slack_notifier: Posts messages to Slack channels or direct messages.
discord_poster: Posts to Discord channels via webhook.
Code and Development Skills
code_runner: Executes Python code in a sandboxed environment and returns output.
code_reviewer: Analyzes code for bugs, security issues, and style improvements.
api_tester: Tests API endpoints and returns response analysis.
regex_builder: Constructs and tests regular expressions for pattern matching.
Building Custom Skills
Custom skills are where the real power unlocks. Here's how to build one that Hermes can use:
Skill File Structure
Every Hermes skill follows this structure:
"""
Skill: [Skill Name]
Description: [What this skill does]
Parameters:
- param1 (str): Description of param1
- param2 (int, optional): Description of param2, default: 10
Returns:
dict with keys: result, status, metadata
Tags: [comma, separated, tags]
Version: 1.0
"""
def execute(param1: str, param2: int = 10) -> dict:
"""
Main execution function. Hermes calls this function.
"""
try:
# Your implementation here
result = do_something(param1, param2)
return {
"status": "success",
"result": result,
"metadata": {
"param1": param1,
"param2": param2
}
}
except Exception as e:
return {
"status": "error",
"error": str(e),
"result": None
}
def do_something(param1, param2):
# Implementation
passExample: Custom Affiliate Link Tracker Skill
Here's a practical custom skill that tracks affiliate link performance:
"""
Skill: affiliate_tracker
Description: Fetches affiliate performance data and returns earnings summary
Parameters:
- platform (str): Affiliate platform name (hostinger, elevenlabs, etc.)
- days (int, optional): Number of days to look back, default: 30
Returns:
dict with earnings summary and top performing links
Tags: affiliate, monetization, tracking
Version: 1.0
"""
import requests
import json
from datetime import datetime, timedelta
def execute(platform: str, days: int = 30) -> dict:
try:
# Each platform has its own API
if platform == "hostinger":
data = fetch_hostinger_data(days)
elif platform == "elevenlabs":
data = fetch_elevenlabs_data(days)
else:
return {"status": "error", "error": f"Unknown platform: {platform}"}
return {
"status": "success",
"result": {
"platform": platform,
"period_days": days,
"total_earnings": data["earnings"],
"clicks": data["clicks"],
"conversions": data["conversions"],
"top_links": data["top_links"]
}
}
except Exception as e:
return {"status": "error", "error": str(e)}Registering Your Skill
After creating the file, register it with Hermes:
python manage_skills.py register --file skills/custom/affiliate_tracker.pyOr through Hermes itself:
Register this new skill from file: skills/custom/affiliate_tracker.pyThe Skill Economy: Sharing and Selling Skills
Here's an underexplored monetization opportunity: skill packs. As your Hermes skill library grows, the individual skills become valuable to other Hermes users.
What Makes a Skill Pack Valuable
Niche specificity: Generic skills are already built-in. Skills for specific niches (e-commerce automation, real estate research, crypto monitoring) are scarce and valuable.
Proven reliability: Skills that you've used for months and refined based on real usage are worth more than first-draft code.
Documentation quality: Well-documented skills with clear use cases, example outputs, and troubleshooting guides are premium products.
Bundling: A "Real Estate Automation Pack" with 15 related skills (MLS scraper, market analysis, listing description writer, email templates) is worth more than any individual skill.
Pricing Strategy
- Single specialty skill: $10-25
- Small pack (5-10 skills): $27-47
- Full niche pack (15-30 skills): $67-97
- Premium pack with documentation and support: $97-197
Where to Sell
- Gumroad: 5% transaction fee, handles payments, instant delivery. Best for independent digital products.
- Your own website: Direct relationship with customers, no platform fees. Requires more setup.
- Hermes Community Discord: Connect with buyers directly. Good for building reputation.
- GitHub Sponsors: If you share some skills publicly and gate the premium ones, GitHub Sponsors works well.
Building a Skill Business
The model: publish 5-10 free skills on GitHub (establishes credibility and generates discovery). Offer premium skill packs for $47-97 each. Build a reputation as the go-to resource for skills in your niche.
The TAM (total addressable market) grows as Hermes adoption grows. Early skill creators who establish their libraries now will have a strong competitive advantage as the community scales.
Skill Maintenance and Optimization
Skills require occasional maintenance as APIs change and your requirements evolve.
Version Management
Update skill version numbers when you make changes:
Version: 1.0 → 1.1 (bug fix)
Version: 1.1 → 2.0 (breaking change in parameters)Performance Monitoring
Hermes logs every skill execution in SQLite. Query your skill performance:
SELECT skill_name,
COUNT(*) as executions,
AVG(execution_time_ms) as avg_time,
SUM(CASE WHEN status='error' THEN 1 ELSE 0 END) as errors
FROM skill_executions
GROUP BY skill_name
ORDER BY executions DESC;Skills with high error rates need attention. Skills with high execution time might benefit from caching or optimization.
The 80/20 of Your Skill Library
After a few months, you'll likely find that 20% of your skills handle 80% of your tasks. Focus optimization efforts on that core 20% — they have the highest impact on your daily productivity.
Advanced: Skill Chaining
Skills can call other skills, enabling complex multi-step automation from a single request:
"""
Skill: content_research_to_draft
Description: Complete pipeline from topic to draft article
"""
def execute(topic: str, target_keyword: str) -> dict:
from skill_runner import run_skill
# Step 1: Research
research = run_skill("web_search", query=f"{topic} latest 2025", num_results=10)
# Step 2: Fetch top competitor articles
for url in research["result"]["urls"][:3]:
content = run_skill("webpage_extract", url=url)
# Step 3: Write article
draft = run_skill("article_writer",
topic=topic,
research_context=research["result"]["summary"],
target_keyword=target_keyword)
return draftThis single skill invocation triggers a complete research-to-draft pipeline. Hermes calls one skill; that skill orchestrates four others internally. The result: powerful automation with simple natural language commands.
Published on ai.quantummerlin.com — Your source for practical AI agent intelligence
