DEV Community: Robin Beraud-Sudreau

Automate Your X/Twitter Workflow with Hermes Tweet: A New AI Agent Skill

Robin Beraud-Sudreau — Sun, 05 Jul 2026 15:33:56 +0000

Automate Your X/Twitter Workflow with Hermes Tweet: A New AI Agent Skill

The Problem: Manual Social Media Monitoring Wastes Time

Managing X/Twitter presence at scale is exhausting. Whether you're monitoring brand mentions, researching competitor activity, or managing community engagement, doing it manually drains productivity. What if your AI agent could handle Twitter research, monitoring, and approved actions automatically?

That's exactly what Hermes Tweet solves—a new marketing skill for the Hermes AI agent that brings X/Twitter automation directly into your AI workflows.

Introducing Hermes Tweet

Hermes Tweet (version 0.1.6) is an open-source skill developed by Xquik that extends Hermes Agent with powerful Twitter/X capabilities. It lets your AI agent:

Search and explore tweets with native Twitter search
Read tweet replies and details for deeper context
Look up user profiles and analytics
Monitor tweet activity in real-time
Export followers for analysis
Gate X actions through Xquik's secure API

How It Works

Hermes Tweet uses three core tools under the hood:

tweet_explore    → Search tweets and discover content
tweet_read       → Fetch tweet details and reply threads
tweet_action     → Execute approved X/Twitter actions

The skill requires network access and environment variables for authentication:

XQUIK_API_KEY                    # Your Xquik API credentials
HERMES_TWEET_ENABLE_ACTIONS      # Enable/disable actions
HERMES_ENABLE_PROJECT_PLUGINS    # Allow trusted plugins

Getting Started with Hermes Agent

Installing Hermes Tweet takes just two commands:

hermes plugins install Xquik-dev/hermes-tweet --enable
hermes tools list

Then set your XQUIK_API_KEY in your Hermes runtime environment—never paste it directly in chat.

Once installed, you can start using natural language prompts with your Hermes Agent:

"Search for tweets mentioning our product launch"
"Get replies to this tweet URL"
"Find followers of @username"
"Monitor mentions of our brand"

The skill handles authentication, API routing, and action gating automatically.

Why This Matters for AI Automation

Hermes Tweet bridges the gap between general-purpose AI agents and specialized social media workflows. Instead of switching between tools, your Hermes Agent now has native Twitter capabilities—perfect for:

Content teams researching trends
Community managers monitoring conversations
Marketing analysts tracking campaign performance
Growth teams discovering influencers

The skill is MIT-licensed and actively maintained by the Xquik team.

Ready to Automate?

Hermes Tweet is now part of the official Hermes skills collection. Check out the full implementation and contribute:

⭐ Star the Hermes Skills repo to stay updated on new AI agent capabilities.

Get started today and let your AI agent handle the Twitter grunt work.

Cleaning Up Personal References: How Hermes Skills Maintains Security Best Practices

Robin Beraud-Sudreau — Thu, 02 Jul 2026 12:50:35 +0000

Cleaning Up Personal References: How Hermes Skills Maintains Security Best Practices

Security in open-source projects isn't just about cryptography and authentication—it's also about preventing accidental exposure of personal data. The Hermes Skills repository just completed a comprehensive security audit, removing lingering personal references that could compromise user privacy.

The Problem: Hidden Personal Data in Documentation

When teams iterate quickly on documentation and examples, personal details can slip through: email addresses in config files, usernames in screenshots, internal URLs, or hardcoded identifiers. While these might seem harmless, they create security vectors and violate privacy principles. The recent cleanup across voxtral-tts, neuronwriter, and other skills demonstrates a mature approach to open-source maintenance.

What Changed

The commit focused on three skill modules:

media/voxtral-tts: Mistral's voice cloning API documentation now uses sanitized voice ID examples
seo/neuronwriter: NeuronWriter integration now removes any site-specific URLs or internal references
README.md: Updated to reflect these changes across the board

These aren't breaking changes—they're hygiene improvements that make the codebase safer for everyone.

Best Practices for Your Own Projects

If you maintain open-source tools, here's what you can learn:

Audit documentation regularly: Search for domain names, email patterns, and UUIDs that might be personal
Use placeholder syntax: Replace real values with clearly marked placeholders like $YOUR_API_KEY or your-domain.com
Review before publishing: Have a checklist: Are there hardcoded URLs? Environment variables? User IDs?
Make it reproducible: Ensure examples work for anyone without requiring personal configuration

How This Improves Hermes Skills

Hermes AI agent users benefit from cleaner, more portable skill definitions. When you integrate the voxtral-tts skill for voice cloning or neuronwriter for SEO optimization, you're working with documentation that prioritizes your privacy while maintaining complete functionality.

The skills still do everything they did before—generate speech with Mistral's API, analyze SEO with NeuronWriter—but now they do it without exposing anyone's personal infrastructure.

Next Steps

If you use Hermes Skills or contribute to the project, you'll notice smoother integration with fewer configuration gotchas. Documentation is now truly generic and reusable.

Want to see the full scope of available skills? Check out the repository and star it if you find it useful:

⭐ github.com/RobinBeraud/hermes-skills

Security through simplicity. That's the Hermes way.

Hermes AI Skills Just Got More Secure: Personal Data Removed from Published Skills

Robin Beraud-Sudreau — Thu, 02 Jul 2026 12:48:24 +0000

The Problem

When building open-source AI agent skills, it's easy to accidentally expose sensitive information in documentation—API keys, personal model IDs, user emails, or custom configuration details. Once published to a repository, this data becomes a security liability for anyone using your skills.

The Hermes AI agent community just took a major step toward fixing this with a significant security push across seven popular skills.

What Changed

A recent commit to the hermes-skills repository removed all personal and sensitive data from published skill documentation. Skills affected include:

marketing/waitlister — removed example waitlist keys and personal URLs
media/photogpt — stripped personal model IDs
media/voxtral-tts — cleaned up voice clone references
media/youtube-content — removed example channel data
productivity/mural — eliminated workspace identifiers
seo/neuronwriter — removed project-specific credentials
wordpress/wpbakery — scrubbed site-specific URLs

Why This Matters

Each skill's documentation now uses placeholder variables (like $YOUR_API_KEY, YOUR_WAITLIST_KEY) instead of real values. This pattern:

✅ Prevents accidental credential leaks

✅ Makes it clearer where users need to insert their own data

✅ Reduces social engineering attack surface

✅ Follows security best practices for open-source projects

How It Works with Hermes

When you use a skill with the Hermes AI agent, it reads credentials from your local environment (typically ~/.hermes/.env). The documentation now explicitly guides you to store sensitive data there:

# In ~/.hermes/.env
WAITLISTER_API_KEY=your_actual_key_here
PHOTOGPT_API_KEY=your_actual_key_here
MURAL_ACCESS_TOKEN=your_actual_token_here

Then skills reference these variables without exposing them in git history or public documentation.

What You Should Do

If you're using any of these skills:

Pull the latest changes — git pull to get the security update
Review your .env file — ensure all credentials are stored locally, not in code
Check your git history — if you've forked the repo, verify no secrets were committed
Update your skill configs — replace any hardcoded values with environment variable references

Contributing Secure Skills

If you're building new skills for Hermes, this commit sets the standard:

Use environment variables for all credentials
Document how to find/generate API keys, but never include examples of real keys
Use placeholder names that make it obvious what needs replacing
Store sensitive docs in private wikis, not public repositories

This is a great reminder that security in open-source isn't just about code—documentation matters too.

Get Involved

The Hermes AI agent is built by the community. If you've spotted other sensitive data in skills or want to contribute a new skill securely, check out the repository and help strengthen the ecosystem.

⭐ Star hermes-skills on GitHub to stay updated on security improvements and new skill releases.

4 New Skills for Hermes AI: Email Marketing, DNS Management, YouTube Moderation & SEO Automation

Robin Beraud-Sudreau — Wed, 01 Jul 2026 16:11:37 +0000

4 New Skills for Hermes AI: Email Marketing, DNS Management, YouTube Moderation & SEO Automation

The Hermes AI agent just leveled up. Four fresh open-source skills are now available to automate email campaigns, manage your DNS infrastructure, moderate YouTube comments, and continuously optimize WordPress sites for search engines.

The Problem

Managing multiple platforms drains time and focus. You're juggling SendFox for newsletters, Gandi for domains, YouTube's comment section, and SEO tools scattered across different tabs. Hermes unifies these workflows into conversational, reusable skills.

What's New?

1. SendFox — Email Marketing Automation

Manage your entire email operation through API calls:

add_contact("contact@example.com", "newsletter", tags=["VIP"], first_name="Alice")
campaign_stats = get_campaign_stats(campaign_id)

Create lists, segment contacts, launch campaigns, and track opens/clicks—all without leaving your AI agent.

2. Gandi — Domain & DNS Management

Stop logging into Gandi's dashboard. Ask Hermes instead:

domains = gandi("GET", "domain/domains")
records = gandi("GET", "livedns/domains/example.com/records")

List domains, check expiration dates, modify DNS records, configure email redirections, and verify your infrastructure—all programmatically.

3. YouTube Comment Management — Moderation & SEO Linking

Stay on top of YouTube comments with:

yt_cm_pending.py — Find unanswered comments across your channel
yt_cm_act.py — Reply or reject comments in bulk
Built-in SEO interlinking to WordPress sites

The skill handles the critical youtube.force-ssl scope requirement so you can actually authenticate and moderate at scale.

4. SEO Optimizer — Continuous Content Improvement

A two-loop system that:

Optimizes existing pages — Fetches your Google Search Console data, identifies high-potential pages, scores them with NeuronWriter, improves content with Claude, and auto-publishes via WordPress.
Creates new articles — Detects genuinely searched topics and generates fresh content on demand.

Run daily: 3 pages → NeuronWriter analysis → Content improvement → Live

How to Use with Hermes

Each skill is drop-in ready. Just set your API keys in .env:

SENDFOX_API_KEY=your_key
GANDI_API_TOKEN=your_token
NEURONWRITER_API_KEY=your_key
GSC_TOKEN=path/to/token.json

Then talk to Hermes naturally:

"Add alice@example.com to my VIP list in SendFox"
"What's the expiration date of my domains?"
"Show me unanswered YouTube comments from the last week"
"Run my daily SEO optimization cycle"

Hermes handles authentication, pagination, error handling, and rate limits transparently.

Why This Matters

These aren't fancy wrappers—they're battle-tested integrations built to solve real workflow friction. The YouTube skill, for example, documents critical gotchas like scope requirements and token-swapping behavior. The SEO skill integrates four different systems (GSC, NeuronWriter, Claude, WordPress) into a cohesive daily routine.

Get Started

All four skills are open-source and ready to use. Check out the repo, explore the skill definitions, and start automating:

Star the hermes-skills repo →

If you build something cool with these skills, share it in the comments. The community is growing, and every integration makes Hermes smarter.

14 New Skills for Hermes AI: From YouTube to TDD

Robin Beraud-Sudreau — Wed, 01 Jul 2026 15:19:53 +0000

14 New Skills for Hermes AI: From YouTube to TDD

The Hermes AI agent just got a major expansion. 14 new generic skills landed in the hermes-skills repository, covering everything from media processing to systematic debugging.

Whether you're automating GitHub workflows, extracting YouTube transcripts, building presentations, or enforcing test-driven development, these skills give your Hermes agent production-ready capabilities.

What's New?

The new skills span five major categories:

Media & Content

youtube-content: Extract transcripts, generate summaries, upload videos, manage channels
voxtral-tts: Mistral voice cloning and text-to-speech (perfect for voiceovers and voice messages)
gif-search: Tenor GIF search via curl — no extra dependencies needed

Productivity

google-workspace: Gmail, Calendar, Drive, Docs, Sheets through OAuth
notion: Notion API + official ntn CLI for pages, databases, and Workers
airtable: REST CRUD operations with Personal Access Tokens
powerpoint: Create, edit, read .pptx files with templates and speaker notes
nano-pdf: Edit PDFs using natural-language instructions

Research

arxiv: Search academic papers by keyword, author, or ID (free API, no key needed)

GitHub

github-repo-management: Clone, fork, create repos; manage releases
github-issues: Create, triage, label, and assign issues
github-pr-workflow: Full PR lifecycle from branch creation to merge

Software Development

test-driven-development: RED-GREEN-REFACTOR enforcement
systematic-debugging: 4-phase root cause debugging methodology

How It Works

Each skill is a standalone module with clear setup instructions, prerequisites, and dual-path implementations. Many skills offer both high-level tools (like gh CLI or ntn) and lower-level fallbacks (curl + Python) for maximum compatibility.

For example, the GitHub issues skill auto-detects your environment:

if command -v gh &>/dev/null && gh auth status &>/dev/null; then
  AUTH="gh"
else
  AUTH="git"  # falls back to curl + token
fi

This means your Hermes agent works everywhere — GitHub runners, containers, headless servers, your laptop.

Using These Skills with Hermes

Once installed, skills integrate seamlessly into your Hermes workflow. Ask your agent naturally:

"Summarize this YouTube video and turn it into a thread"
"Create a presentation deck from this outline"
"Search arXiv for papers on reinforcement learning from the last month"
"Create a GitHub issue for this bug with these labels"
"Write a test first, then implement the retry logic"

Hermes picks the right skill, handles authentication (via .env or existing credentials), and executes the command. No manual setup for each task — just ask.

Why This Matters

These skills solve real workflow pain:

No more context switching between YouTube, Notion, Gmail, and your code editor
Automation without custom glue code — Hermes handles the orchestration
Methodology enforcement — TDD and systematic debugging skills keep you honest
Production-ready — dual implementations mean reliability across environments

The test-driven development and systematic debugging skills are especially powerful. They don't just execute commands — they enforce discipline, ensuring you write tests before code and find root causes before applying fixes.

Get Started

Head to the hermes-skills repository and explore the skills that match your workflow:

github.com/RobinBeraud/hermes-skills

Each skill includes detailed documentation, examples, and prerequisites. Start with the ones you use daily (Gmail, GitHub, Notion) and expand from there.

If you're building with Hermes or contributing skills, please star the repo at https://github.com/RobinBeraud/hermes-skills — it helps the community discover what's possible.

Generate Realistic Photos with PhotoGPT in Hermes AI — Now with Personal Model Support

Robin Beraud-Sudreau — Thu, 25 Jun 2026 08:49:43 +0000

Generate Studio-Quality Photos Programmatically

Imagine building an AI workflow that generates realistic headshots, LinkedIn photos, or workshop scenes on demand—without hiring a photographer or spending hours editing. The new PhotoGPT skill for Hermes AI does exactly that.

What Problem Does This Solve?

Content creators, recruiters, and marketing teams often need realistic photos for profiles, presentations, or social media. Traditional solutions require either hiring photographers or using generic stock images. PhotoGPT bridges this gap by leveraging AI to generate authentic-looking photos of real people—including support for personal trained models (like the Robin model) that capture specific individuals.

The Hermes integration makes it seamless: generate a photo → automatically upload to Mural via Azure Blob storage. No manual handoffs. No API fumbling.

How It Works

The PhotoGPT skill uses an async job-polling pattern:

Submit a generation request with a prompt (e.g., "Robin in a professional headshot, blue background")
Receive a jobId immediately
Poll the endpoint until the image is ready
Optionally upscale the result for higher quality
Upload to Mural if needed

Under the hood, it bypasses Cloudflare blocks by using curl via subprocess instead of Python's urllib—a practical workaround documented in the skill.

Getting Started with Hermes

The PhotoGPT skill supports two model types:

Personal Models — Like the Robin model (ID: 019abc8d-e721-7066-80ee-e7286e27d007), trained on real photos. Perfect for consistent character representation across multiple images. Costs 10 credits per image.

Public Models — Free or low-cost alternatives like nanobanana, seedream, or gpt-image-2. Great for experimentation and bulk generation.

Simply authenticate with your PHOTOGPT_API_KEY and PHOTOGPT_MODEL_ROBIN (stored in ~/.hermes/.env), then craft your prompt:

Generate a professional LinkedIn photo of Robin, medium shot, office background, warm lighting

The skill handles credits validation, training status checks, and error recovery automatically. It even integrates with Mural—generate a photo and upload it directly to your team's workspace.

Real-World Prompt Ideas

Headshots: "Professional headshot, neutral background, studio lighting"
Social Media: "Casual portrait, outdoor setting, natural lighting"
Workshop Scenes: "Group of people in a workshop, collaborative atmosphere"
LinkedIn: "Corporate portrait, business attire, office environment"

Why This Matters for AI Workflows

Hermes AI agents can now autonomously generate visual content, reducing bottlenecks in content pipelines. Imagine a recruitment workflow that auto-generates candidate materials, or a marketing agent that refreshes team photos monthly—all hands-free.

The async job pattern also teaches a practical lesson in building resilient AI integrations: not every API responds instantly, and polling gracefully handles real-world delays.

Next Steps

Check out the full skill documentation and examples in the hermes-skills repo. The PhotoGPT skill is production-ready with comprehensive error handling and Mural integration.

⭐ If this powers your AI workflow, star the repo: https://github.com/RobinBeraud/hermes-skills

Mural Skill for Hermes AI Agent - Auth Fix & New Helper Script

Robin Beraud-Sudreau — Wed, 24 Jun 2026 08:40:47 +0000

What Changed

The Mural skill for Hermes AI Agent just got a significant update, thanks to Hermes fixing its own bugs after real-world usage.

The Bug: Token Refresh Was Broken

The original implementation put client_id and client_secret in the request body when refreshing OAuth tokens. Mural's API rejects this with 400 invalid_client.

The fix: Mural requires HTTP Basic authentication for token refresh - credentials go in the Authorization header, not the body.

`python
import base64, urllib.request, urllib.parse

creds = base64.b64encode(f"{CLIENT_ID}:{CLIENT_SECRET}".encode()).decode()

req = urllib.request.Request(
"https://app.mural.co/api/public/v1/authorization/oauth2/token",
data=urllib.parse.urlencode({
"grant_type": "refresh_token",
"refresh_token": REFRESH_TOKEN,
}).encode(),
headers={
"Authorization": f"Basic {creds}",
"Content-Type": "application/x-www-form-urlencoded",
}
)
`

New: mural_api.py Helper Script

Hermes also wrote a ready-to-use client script (~/.hermes/scripts/mural_api.py) that:

Auto-refreshes the token when it expires (every 15 min)
Rewrites tokens back to .env automatically (refresh tokens are rotated)
Avoids credential leakage via shell inline commands

ash python3 ~/.hermes/scripts/mural_api.py refresh # force refresh python3 ~/.hermes/scripts/mural_api.py get /workspaces # authenticated GET python3 ~/.hermes/scripts/mural_api.py get /workspaces/<id>/murals

What Hermes Can Do with Mural Now

Create full workshop boards from a document (we built a 40-widget training day board from a DOCX)
Add stickies, shapes, connectors programmatically
List and search murals across workspaces and rooms
Duplicate murals from templates

Get the Skill

~/.hermes/skills/productivity/mural/SKILL.md

Or browse it on GitHub: https://github.com/RobinBeraud/hermes-skills

Hermes is an open-source AI agent framework. Skills are markdown files that teach it how to use APIs. Star the repo if you find it useful!

Automate Mural Board Creation with Hermes AI Agent

Robin Beraud-Sudreau — Tue, 23 Jun 2026 15:38:45 +0000

Automate Mural Board Creation with Hermes AI Agent

The Problem

Managing visual collaboration boards manually is tedious. Creating murals, organizing them across workspaces and rooms, populating them with widgets—it all takes time. What if your AI agent could handle it all?

The new Mural skill for Hermes AI agent brings programmatic control over your Mural boards, enabling intelligent automation of collaborative workspace management.

What's New

The Mural collaboration skill lets you:

Create and manage workspaces & rooms across your Mural environment
Build boards dynamically with full CRUD operations
Populate murals instantly with sticky notes, shapes, text, images, and connectors
Duplicate and organize existing boards
Handle authentication seamlessly with automatic token refresh

How It Works

The skill integrates with Mural's official API, communicating via standard REST endpoints:

GET /workspaces                    # List all workspaces
POST /rooms/{roomId}/murals        # Create a new mural
POST /murals/{muralId}/widgets     # Add widgets (stickies, shapes, text, etc.)
PATCH /murals/{muralId}            # Update mural metadata
DELETE /murals/{muralId}           # Clean up when done

Authentication uses Bearer tokens stored in your .hermes/.env file:

MURAL_ACCESS_TOKEN=your_token_here
MURAL_REFRESH_TOKEN=your_refresh_token
MURAL_CLIENT_ID=your_client_id
MURAL_CLIENT_SECRET=your_client_secret

Tokens refresh automatically when they expire (15-minute validity), so your agent keeps working without interruption.

Using It with Hermes

Once installed, you can instruct Hermes to perform complex board operations in natural language:

"Create a retrospective mural in the Design room with columns for 'What went well', 'What didn't', and 'Action items'. Add sticky note templates for team feedback."

Hermes translates this into API calls:

Fetch the workspace and room IDs
Create the mural
Populate it with text headers (the three columns)
Add sticky note widgets ready for input

This is perfect for:

Sprint retrospectives – auto-generate board layouts
Design workshops – set up collaborative canvases with templates
Process documentation – create visual workflows with connectors and shapes
Team onboarding – standardized collaboration boards

Getting Started

The skill is production-ready and open-source. Head to the hermes-skills repository to integrate it:

→ github.com/RobinBeraud/hermes-skills

Instructions for setup and API documentation are in productivity/mural/SKILL.md.

Why This Matters

AI agents work best when they can manipulate real tools. By giving Hermes access to Mural, you're enabling intelligent workspace automation—no more manual board creation, no context switching. Your agent becomes a genuine productivity multiplier.

⭐ If this sounds useful, star the repo and let's build more agent skills together!

Questions? Check out the skill documentation or open an issue on GitHub.

Automate Mural Boards with Hermes AI: Visual Collaboration at Scale

Robin Beraud-Sudreau — Tue, 23 Jun 2026 15:37:37 +0000

Transform Your Visual Collaboration Workflow

Managing Mural boards manually is time-consuming. Whether you're facilitating design sprints, running brainstorming sessions, or organizing complex projects, creating and populating boards across multiple workspaces and rooms drains productivity hours.

The new Mural skill for Hermes AI solves this by automating board creation, management, and population—letting you focus on what matters: the ideas themselves.

What You Can Now Do

With the Hermes Mural skill, you can programmatically:

Create and organize workspaces and rooms
Generate murals on demand with custom titles and descriptions
Populate boards instantly with:
- Sticky notes (perfect for ideation automation)
- Shapes and text elements
- Images from URLs
- Connectors (for flowcharts and relationships)
Manage content by updating, duplicating, or deleting boards
List and retrieve workspace contents in seconds

How It Works

The skill connects directly to the Mural API v1 using OAuth2 authentication. It handles token refresh automatically, so you never worry about 401 errors interrupting your workflows.

Workspace → Room → Mural → Widgets (Stickies, Shapes, Text, Images, Connectors)

Simply provide your MURAL_ACCESS_TOKEN (stored securely in ~/.hermes/.env), and the skill manages the rest—including automatic token refresh when needed.

Using It with Hermes AI

Imagine this scenario: Your PM asks Hermes to "create a design sprint board for the Q2 roadmap."

Hermes now can:

Create a new room in your workspace
Generate a mural titled "Q2 Roadmap Design Sprint"
Automatically populate it with sticky notes for each epic
Add connector lines showing dependencies
Share the link back to you—ready to collaborate

No manual board setup. No copy-paste drudgery. Just intelligent automation.

Getting Started

Install the Mural skill in your Hermes setup
Configure your MURAL_ACCESS_TOKEN in ~/.hermes/.env
Prompt Hermes naturally: "Create a mural for...", "List my workspaces", "Add sticky notes with..."

The skill supports all Mural widget types and handles the full workspace hierarchy—from high-level organization down to individual board elements.

Open Source & Community-Driven

This skill is part of the hermes-skills open-source project, meaning you can inspect the code, contribute improvements, or fork it for your specific needs.

⭐ If you find this useful, please star the repo: https://github.com/RobinBeraud/hermes-skills

Your support helps maintain and expand Hermes capabilities for the entire community. Happy automating! 🚀

Hermes Skills: Building a Comprehensive Skill Library for Your AI Agent

Robin Beraud-Sudreau — Sun, 21 Jun 2026 14:22:50 +0000

Hermes Skills: Building a Comprehensive Skill Library for Your AI Agent

The Challenge of AI Agent Extensibility

Building intelligent AI agents is exciting, but here's the reality: a single model can only do so much out of the box. You need a way to extend your agent's capabilities without reinventing the wheel every time. That's where modular, reusable skills come in—and the Hermes Skills project just made it much easier to get started.

Introducing Hermes Skills

The hermes-skills repository is an open-source collection of pre-built, production-ready skills designed specifically for the Hermes AI agent framework. Whether you need data processing, API integrations, or utility functions, Hermes Skills provides a growing library of composable abilities that your agent can leverage.

A recent update to the README brings much-needed clarity with a comprehensive skills table and streamlined quick-start guide, making it easier than ever to explore what's available and get up and running.

How Skills Work in Hermes

Each skill in Hermes is self-contained and follows a consistent structure. Here's a simplified example of what a skill looks like:

from hermes.skill import Skill

class DataProcessingSkill(Skill):
    """Processes and transforms data"""

    def execute(self, input_data):
        # Your skill logic here
        return processed_data

Skills are registered with your Hermes agent and can be discovered and invoked at runtime. This modular approach means you can mix and match exactly what your agent needs without bloating your codebase.

Getting Started with Hermes Agent

Integrating Hermes Skills into your AI agent is straightforward:

Browse the updated README – Check the new skills table to see what's available
Clone or install – Add the hermes-skills repo to your project
Register skills – Load the skills you need into your Hermes agent
Let your agent learn – The agent can now use these capabilities to handle complex tasks

The updated quick-start guide walks you through this process with clear examples and best practices.

Why This Matters

Open-source skill libraries like this democratize AI development. Instead of each team building the same integrations and utilities from scratch, we can collaborate and build on shared foundations. The improved documentation means more developers can contribute skills, report issues, and suggest improvements.

Join the Community

Hermes Skills is actively maintained and growing. Whether you're looking to extend your agent's capabilities or contribute your own skills back to the community, there's room for you.

Ready to supercharge your Hermes agent? Head over to the repository and explore the full skills table—you might find exactly what you need.

⭐ Please star the repository at https://github.com/RobinBeraud/hermes-skills to support the project and stay updated on new skills!

Firecrawl Skill for Hermes: Transform Any Website into Clean Markdown

Robin Beraud-Sudreau — Sun, 21 Jun 2026 13:39:01 +0000

Firecrawl Skill for Hermes: Transform Any Website into Clean Markdown

The Problem

Web data is everywhere, but getting it into a clean, usable format for AI agents is a pain. Raw HTML is noisy, JavaScript-rendered pages can't be scraped with simple HTTP requests, and building reliable web extraction pipelines from scratch takes significant engineering effort.

That's exactly why we built the Firecrawl skill for Hermes — a plug-and-play integration that gives your AI agent instant access to clean web content, search results, and browser interactions.

What the Firecrawl Skill Does

With a single skill install, your Hermes AI agent can:

Scrape any URL and get back clean Markdown — no HTML noise
Search the web and retrieve full page content from results
Crawl entire websites systematically
Interact with dynamic pages — fill forms, click buttons, handle JavaScript
Extract structured data as JSON from any page

How It Works

The skill wraps Firecrawl's v2 API with a simple Python helper:

import os, urllib.request, json

BASE = "https://api.firecrawl.dev/v2"
KEY = os.environ["FIRECRAWL_API_KEY"]

def firecrawl(endpoint, payload):
    data = json.dumps(payload).encode()
    req = urllib.request.Request(
        f"{BASE}/{endpoint}",
        data=data,
        headers={"Authorization": f"Bearer {KEY}", "Content-Type": "application/json"}
    )
    return json.loads(urllib.request.urlopen(req).read())

Scraping a page is then one line:

result = firecrawl("scrape", {"url": "https://example.com", "formats": ["markdown"]})
print(result["data"]["markdown"])

Real-World Examples

Web search with full content:

results = firecrawl("search", {"query": "best Python frameworks 2026", "limit": 5})
for r in results["data"]:
    print(f"{r['title']} — {r['url']}")

Extract structured data:

result = firecrawl("scrape", {
    "url": "https://shop.example.com/product/123",
    "formats": ["extract"],
    "extract": {"prompt": "Extract product name, price, and availability"}
})
print(result["data"]["extract"])
# → {"name": "...", "price": 29.99, "availability": "In Stock"}

Interact with dynamic pages:

result = firecrawl("interact", {
    "url": "https://example.com/login",
    "actions": [
        {"type": "fill", "selector": "#email", "value": "user@example.com"},
        {"type": "click", "selector": "#submit"},
        {"type": "scrape", "formats": ["markdown"]}
    ]
})

Using It with Hermes

Add your API key to ~/.hermes/.env:

   FIRECRAWL_API_KEY=your_key_here

Get your key at firecrawl.dev
Ask your Hermes agent naturally:
- "Scrape https://news.ycombinator.com and summarize the top stories"
- "Search for Python best practices and give me a summary"
- "Extract all product prices from this e-commerce page"

Hermes routes these requests to the Firecrawl skill automatically.

Get Started

The Firecrawl skill is now live in the hermes-skills repository. ⭐ Star it to follow future skill releases — we're building the toolkit for production AI agents, one skill at a time.

Build Financial Analysis into Your Hermes AI Agent with the FMP Skill

Robin Beraud-Sudreau — Sat, 20 Jun 2026 22:14:53 +0000

Build Financial Analysis into Your Hermes AI Agent with the FMP Skill

The Problem

Building AI agents that can answer real-time financial questions is tough. You need reliable data sources, API integrations, and the right abstractions to make it seamless. That's why the Hermes community just shipped something powerful: the Financial Modeling Prep (FMP) skill.

Whether you're building a financial chatbot, an investment research assistant, or an autonomous trading dashboard, you now have a plug-and-play skill that gives your Hermes AI agent instant access to professional-grade financial data.

What Can You Do?

The FMP skill connects Hermes to real-time market data across multiple asset classes:

Stock quotes & fundamentals — real-time prices, company profiles, income statements
Financial ratios — P/E ratios, dividend yields, debt-to-equity metrics
Stock screeners — filter stocks by market cap, PE ratio, or custom criteria
Crypto & forex prices — Bitcoin, Ethereum, EUR/USD, and more
Market indices — CAC40, S&P 500, Nasdaq snapshots
News & movers — trending stocks and market sentiment

How It Works

The skill is built on a clean abstraction over Financial Modeling Prep's stable API (v2025+):

def fmp(path, **params):
    params["apikey"] = os.environ["FMP_API_KEY"]
    qs = "&".join(f"{k}={v}" for k, v in params.items())
    url = f"https://financialmodelingprep.com/stable/{path}?{qs}"
    return json.loads(urllib.request.urlopen(url).read())

With this helper, querying data is one line:

# Get Apple's current stock price
price = fmp("quote", symbol="AAPL")
print(f"AAPL: ${price[0]['price']} ({price[0]['changesPercentage']:+.2f}%)")

Using It with Hermes

Setup is straightforward:

Get an API key from financialmodelingprep.com
Add it to your Hermes config (~/.hermes/.env):

   FMP_API_KEY=your_key_here

Ask your agent — now you can ask natural questions like:
- "What's the current price of Tesla?"
- "Show me the PE ratio for Microsoft"
- "Find stocks with market cap > $100B and PE < 15"
- "What's Bitcoin trading at right now?"

Hermes will automatically route these queries to the FMP skill and deliver formatted, contextual answers.

Why This Matters

Financial data is increasingly important for AI agents. This skill removes the friction of integrating FMP—you get:

✅ Standardized endpoints — no guessing which API version to use
✅ Error handling baked in — reliable queries that don't break
✅ Community-maintained — open-source means transparency and improvements
✅ Production-ready — using stable API endpoints

Get Started

The FMP skill is live in the hermes-skills repository. If you're building financial AI agents, check it out and give the repo a ⭐ to support the project.

Have ideas for other financial endpoints? PRs welcome—let's build the financial data layer for AI agents together.