Most AI tools are useful for a few minutes.

Then the pain starts.

You explain your business. You explain your codebase. You explain your writing style. You explain your tools. You explain your rules. Then you open a new chat tomorrow and explain it all again.

That is not a real assistant. That is a smart stranger with a short memory.

Hermes Agent is built for a different job. It is made to become more useful the longer it works with you. It can store useful facts, search past sessions, create reusable skills, connect to messaging apps, use tools, and run scheduled tasks.

This is why Hermes matters.

A chatbot answers.

An agent acts.

A self-improving agent learns how you work, then repeats that work with less hand-holding each time.

This guide will help you move from beginner to advanced user. You will learn how Hermes works, how to set it up, how to use memory, how to create skills with /learn, how to connect messaging gateways, how to run cron jobs, how to use MCP, and how to stay safe while giving an AI agent real power.

# TL;DR

• Hermes Agent is an open-source AI agent from Nous Research that can remember, use tools, create skills, run scheduled tasks, and work across messaging apps.
• It is not just a chatbot. It can search, browse, read files, edit files, run commands, use MCP tools, and automate repeat work.
• Its core power comes from memory, skills, context files, tools, and messaging gateways.
• The /learn command can turn docs, URLs, folders, pasted notes, or a workflow you just taught it into a reusable skill.
• Messaging gateways let Hermes live in Telegram, Discord, Slack, WhatsApp, Signal, email, SMS, Matrix, Home Assistant, Teams, and more.
• Hermes Desktop gives you a native app for macOS, Windows, and Linux while using the same core agent, config, keys, sessions, skills, and memory as the CLI.
• Advanced users should learn profiles, sessions, context references, MCP, cron, checkpoints, /goal, /handoff, and subagent delegation.
• Do not treat Hermes like a harmless chatbot. It can act on files, shell commands, apps, and connected systems. Use sandboxes, approvals, allowlists, and limited tool access.

# What Is Hermes Agent?

Hermes Agent is an open-source autonomous AI agent built by Nous Research. It can run on your local machine, Docker, SSH, Daytona, Modal, Singularity, a VPS, or other setups. It can also talk to you through the terminal, TUI, Telegram, Discord, Slack, WhatsApp, Signal, email, SMS, Matrix, Home Assistant, Microsoft Teams, and more.

In plain English, Hermes is a personal AI operator.

It can:

• Chat with you
• Remember useful facts
• Read and edit files
• Run terminal commands
• Browse and search the web
• Use image, voice, and browser tools
• Create and reuse skills
• Schedule jobs
• Connect to messaging platforms
• Use MCP servers
• Run separate profiles for different jobs
• Hand sessions from CLI to chat apps
• Delegate work to child agents

That makes it different from a normal AI assistant.

A normal assistant waits in a chat box. Hermes can live where you work.

# Why Hermes Agent Is Worth Learning

Hermes is worth learning because it solves five big AI workflow problems.

# It Can Remember What Matters

Hermes has persistent memory. It stores key facts in MEMORY.md and user preferences in USER.md.

That means Hermes can remember things like:

• Your preferred writing style
• Your project stack
• Your command habits
• Your folder structure
• Your business rules
• Lessons from past mistakes

This is not the same as dumping every chat into memory. Good memory is short, useful, and durable.

# It Can Search Old Sessions

Hermes stores sessions so it can resume chats and search past work.

This matters because not everything belongs in memory.

Memory is for facts Hermes should always know.

Session search is for things Hermes may need to find later.

For example:

• “What did we decide last week about the landing page?”
• “Find the session where we fixed the auth bug.”
• “What prompt did we use for the product image?”
• “Show me the old plan for the SEO article.”

# It Can Turn Workflows Into Skills

Skills are reusable instruction files that Hermes can load only when needed.

This is where Hermes becomes more than a memory system.

A memory says, “The user prefers short copy.”

A skill says, “Here is the exact process for creating a high-converting blog brief, including research, structure, headings, examples, and final checks.”

The more you turn repeat work into skills, the more useful Hermes becomes.

# It Can Work Across Apps

Hermes has a messaging gateway. That means you can talk to it outside the terminal.

You can use it from:

• Telegram
• Discord
• Slack
• WhatsApp
• Signal
• Email
• SMS
• Matrix
• Mattermost
• Home Assistant
• Microsoft Teams

This changes the use case.

You can ask Hermes to send you a morning brief, watch a Slack channel, handle a Discord workflow, send alerts, continue a terminal session from your phone, or trigger work from email or webhooks.

# It Can Automate Repeat Work

Hermes supports scheduled tasks through cron.

That makes Hermes useful for:

• Daily research
• Weekly reports
• Uptime checks
• Repo audits
• Content monitoring
• Inbox summaries
• Market tracking
• Team updates

The best use case is not “make Hermes do everything.”

The best use case is “teach Hermes one repeat task, make it reliable, then automate it.”

# Who Should Use Hermes Agent?

Hermes is best for people who have repeat digital work.

It is especially useful for:

• Software engineers
• Technical founders
• Marketers
• SEO teams
• Content teams
• Researchers
• Operators
• System admins
• Indie hackers
• Power users
• AI automation builders

Hermes is not ideal if you only want a clean chatbot with no setup.

It is also not ideal if you want to give an AI full access to private files without learning the safety model first.

The right mindset is this:

Treat Hermes like a junior operator with tools.

Not like a magic box.

Not like a toy.

Not like a harmless text field.

# How Hermes Agent Works

Hermes has several major parts. Once you understand them, the whole system becomes easier to use.

# The Model

Hermes needs an AI model to think, plan, and respond.

You can configure providers with:

hermes model

You can use hosted models, local models, custom endpoints, or provider routers. A beginner should use the easiest stable provider first.

Do not start by tuning routing, fallback, local models, and custom endpoints. Get one clean model working first.

# The Tools

Tools give Hermes hands.

Hermes can use tools for:

• Web search
• Browser automation
• Terminal commands
• File operations
• Memory
• Session search
• Delegation
• Scheduled jobs
• Media
• Messaging
• MCP
• Home Assistant

You can configure tools per platform with:

hermes tools

This matters because your Telegram bot should not always have the same powers as your local coding agent.

# The Memory

Hermes uses bounded memory.

Its two main memory files are:

Hermes can also search old sessions. Memory is limited and always loaded. Session search is larger and used only when needed.

A good memory entry is compact:

User writes for a general audience. Use clear, simple words, short sentences, and no filler.

A bad memory entry is vague:

User likes writing.

# The Skills System

Skills are on-demand knowledge documents.

They teach Hermes how to do a task. They can include steps, rules, warnings, examples, and verification checks.

Skills can be used as slash commands:

/plan create a rollout plan for the payment refactor

Or:

/github-pr-workflow review this change and prepare a PR

The more you turn repeat work into skills, the less you need to repeat yourself.

# The Beginner Path: Your First Working Hermes Setup

Do not try to master everything on day one.

Your first goal is simple:

Get Hermes installed, choose a provider, run one chat, and resume a session.

# Step 1: Install Hermes

On Linux, macOS, WSL2, or Termux, the common install path is:

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

You can also install with pip:

pip install hermes-agent
hermes postinstall

# Step 2: Choose a Model

Run:

hermes model

This opens the provider and model setup flow.

If you want the fastest guided path, use:

hermes setup --portal

# Step 3: Start Chatting

Run:

hermes

Or use the TUI:

hermes --tui

Test with something concrete:

Check my current directory and tell me what project this looks like.

A good first test should prove that:

• Hermes starts
• The model responds
• Tools are available
• It can inspect your environment
• You can continue the chat

# Step 4: Resume the Session

Run:

hermes --continue

Or:

hermes -c

This confirms session storage works.

If this fails, fix it before moving to bots, cron, or MCP.

# Hermes Agent Desktop: The Visual Front Door

Hermes Agent is not only a terminal tool.

Hermes Desktop is the native app for people who want the same agent in a cleaner visual interface. It runs on macOS, Windows, and Linux. The key point is that Hermes Desktop is not a separate lightweight product. It uses the same Hermes Agent core as the CLI and gateway.

That means it shares:

• The same config
• The same API keys
• The same sessions
• The same skills
• The same memory
• The same agent behavior

If you set up Hermes in the terminal, Desktop can use that setup. If you work in Desktop, the work can still show up in the CLI-side Hermes world.

# When Hermes Desktop Makes Sense

Use Hermes Desktop when you want the power of Hermes without living in the terminal all day.

It is useful for:

• Beginners who want a visual starting point
• Teams that need a less technical interface
• Users who want chat, settings, projects, and agent activity in one app
• People who prefer managing sessions visually
• Users who want to drag files into chat instead of typing paths
• People who want a friendlier way to switch models, projects, or profiles

Desktop is also useful when you are showing Hermes to someone else. A native app is easier to explain than a terminal full of commands.

# Desktop vs CLI vs TUI vs Dashboard

Hermes has several surfaces. They are not all the same.

Use Desktop when you want a polished app.

Use CLI when you want speed, scripts, and direct control.

Use the gateway when you want Hermes to meet you in chat.

Use the dashboard when you want to manage the installation from a browser.

# How to Install Hermes Desktop

For macOS and Windows, the easiest path is the Hermes Desktop installer from the official Hermes Agent website.

For Linux, macOS, or Windows through the CLI installer, you can include Desktop during install:

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash -s -- --include-desktop

If you already have Hermes installed, run:

hermes desktop

That uses your current Hermes setup.

# What You Can Do in Hermes Desktop

Hermes Desktop is useful because it gives the agent a more approachable workspace.

Depending on your setup, you can use it to:

• Chat with Hermes in a native app
• See streaming responses
• Watch tool activity as Hermes works
• Manage multiple conversations
• Work with projects and files
• Configure settings without editing YAML by hand
• Use existing skills and memory
• Switch between profiles or projects more easily
• Use Hermes as a daily assistant without keeping a terminal open

This matters for adoption.

The terminal is powerful, but it can scare people away. Desktop gives Hermes a clearer front door.

# Best Hermes Desktop Workflow

Here is a simple way to use Desktop well:

1. Install Hermes.
2. Run the setup flow.
3. Confirm one clean chat works.
4. Open Hermes Desktop.
5. Start a new session for one clear task.
6. Add project context or files.
7. Turn repeated tasks into skills with /learn.
8. Use CLI or gateway only when they are the better fit.

Desktop should not replace every interface.

Think of it as the main visual workspace. The CLI is still best for scripts and deep terminal work. Messaging gateways are still best for remote access and alerts.

# Desktop Safety Notes

Desktop looks friendlier than the terminal, but it is still the same agent.

That means the same safety rules apply:

• Do not give it broad access on day one.
• Keep approvals on.
• Use sandboxed backends for risky work.
• Review memory and skill writes if the workflow is sensitive.
• Be careful with connected tools, files, and credentials.
• Use separate profiles for separate jobs.

The visual interface makes Hermes easier to use. It does not make powerful actions harmless.

# The Real Learning Path: Beginner to Advanced in Days

Here is a practical path.

# Day 1: Install and Chat

Learn:

• hermes
• hermes chat
• hermes model
• hermes doctor
• hermes --continue
• /help
• /status
• /new
• /model

Your goal is basic comfort.

Do not add automation yet. Do not install every skill. Do not connect every chat app.

Just make sure the core loop works.

# Day 2: Add Memory and Context

Learn:

• MEMORY.md
• USER.md
• /memory
• AGENTS.md
• .hermes.md
• SOUL.md
• @file
• @diff
• @folder
• @url

Context files tell Hermes how to behave inside a project.

Hermes can use files such as:

• .hermes.md
• HERMES.md
• AGENTS.md
• CLAUDE.md
• SOUL.md
• .cursorrules
• .cursor/rules/*.mdc

Use AGENTS.md for project rules.

Use SOUL.md for the agent’s style and default voice.

Use memory for durable facts that should survive across sessions.

Use context references when you want to attach exact files or diffs to a message.

Examples:

Review @diff and look for security issues.

Summarize @file:README.md and @folder:src.

Compare this approach with @url:https://example.com/article.

# Day 3: Create Skills With /learn

This is one of the most important Hermes features.

The /learn command lets Hermes create a reusable skill from almost anything:

• A directory
• A URL
• Pasted notes
• Docs
• A workflow you just taught it
• A task you repeat often

Examples:

/learn how I write SEO blog posts from keyword research, search intent, pain points, structure, and final editing rules

/learn the API docs at https://example.com/docs, focus on auth, pagination, and error handling

/learn how I just deployed the staging server

/learn this support workflow: check account status, review latest ticket, draft reply, tag issue, escalate if payment failed

Use /learn when you catch yourself explaining the same workflow twice.

That is the signal.

A beginner asks Hermes to do the same thing again.

An advanced user teaches Hermes the workflow once, then calls it as a skill.

# Day 4: Connect Messaging Gateways

Messaging gateways turn Hermes from a terminal tool into a real assistant.

Run:

hermes gateway setup

Then configure your platform.

Common options include:

• Telegram
• Discord
• Slack
• WhatsApp
• Signal
• Email
• SMS
• Matrix
• Mattermost
• Home Assistant
• Microsoft Teams

Use:

hermes gateway run

or:

hermes gateway start

Inside a messaging app, use:

/sethome

This marks that chat as the home channel for deliveries.

You can then hand off a CLI session to a messaging platform:

/handoff telegram

This is powerful.

You can start deep work on your computer, then continue from your phone.

# Day 5: Add Automation With Cron

Once Hermes can do a task well, schedule it.

Use:

/cron add "every morning at 9" "Research AI agent news and send me a short brief"

Or from the shell:

hermes cron create "every 1d at 09:00" "Check open PRs and summarize what needs review"

Cron jobs can use skills:

hermes cron create "every 1h" "Check feeds and summarize new items" --skill blogwatcher

Start with low-risk jobs:

• Summaries
• Reports
• Monitoring
• Drafts
• Reminders
• Research

Wait before scheduling anything that edits files, sends emails, deploys code, or touches production systems.

# Day 6: Add MCP and External Tools

MCP lets Hermes connect to outside tool servers.

That can include:

• GitHub
• Databases
• File systems
• Browser tools
• Internal APIs
• Project management tools
• Business systems

Set up MCP only after your base Hermes install works.

A simple MCP config looks like this:

mcp_servers:
  filesystem:
    command: "npx"
    args: ["-y", "@modelcontextprotocol/server-filesystem", "/home/user/projects"]

The key rule:

Expose only the tools Hermes needs.

Do not give it every tool because it feels exciting.

Power without limits becomes cleanup work.

# Day 7: Split Work With Profiles

Profiles let you run several independent Hermes agents on one machine.

Each profile can have its own:

• Config
• API keys
• Memory
• Sessions
• Skills
• Cron jobs
• Gateway state

Example:

hermes profile create coder
coder setup
coder chat

You might create profiles like:

Profiles are not sandboxes. They separate Hermes state, not your whole filesystem.

If the local backend has access to your files, a profile does not block that by itself.

# The Hermes Command Map

Hermes has two main command surfaces:

• Shell commands, like hermes model
• In-chat slash commands, like /model

This difference matters.

# Essential Shell Commands

# Essential Slash Commands

Installed skills can also become dynamic slash commands.

If you create a skill named seo-brief, you may be able to call it like this:

/seo-brief create a blog brief for "best AI tools for small business"

# Messaging Gateways: Use Hermes Where You Already Work

Messaging gateways are one of Hermes Agent’s biggest strengths.

They turn Hermes into a bot you can use from your normal communication tools.

# What Gateways Are For

Use a gateway when you want Hermes to:

• Send you reports
• Receive tasks from your phone
• Work in team channels
• Trigger workflows from chat
• Deliver alerts
• Continue sessions outside the terminal
• Let approved users interact with an agent

# Common Gateway Patterns

# Personal Telegram Assistant

Use for:

• Daily briefs
• Reminders
• Quick research
• Link summaries
• Server alerts
• Voice notes

# Discord Team Bot

Use for:

• Developer support
• Repo summaries
• Release notes
• Community workflows
• Moderator support

# Slack Work Assistant

Use for:

• Standups
• PR summaries
• Support triage
• Incident reports
• Team reminders

# Email Assistant

Use for:

• Inbox summaries
• Draft replies
• Follow-up reminders
• Report delivery

# Home Assistant Bot

Use for:

• Smart home control
• Status questions
• Home alerts
• Routine automation

# Gateway Safety

Gateways need strict permissions.

Use admin and user command splits when your platform supports them.

A team member who only needs /help, /status, and /new should not have /yolo, /model --global, or broad tool access.

Also avoid giving risky toolsets to public or shared channels.

For example:

• A private Telegram bot can use research tools.
• A coding profile can use terminal and file tools.
• A team Slack bot may only need summaries and reports.
• A public Discord bot should have the smallest toolset possible.

# Advanced Hermes Agent Use Cases

# Use Case 1: AI Research Analyst

Workflow:

1. Create a researcher profile.
2. Enable web tools.
3. Create a research skill with /learn.
4. Schedule daily or weekly research with /cron.
5. Deliver results to Telegram or Slack.

Example:

/learn my research workflow: define the question, search primary sources, compare claims, extract useful data, cite sources, and end with clear next steps.

Then:

/cron add "every Monday at 8am" "Research new AI agent security papers and send me a clear summary"

# Use Case 2: SEO Content Operator

Workflow:

1. Create a marketer profile.
2. Add your writing rules to USER.md.
3. Create skills for blog briefs, outlines, and final edits.
4. Use @url for competitor pages.
5. Use /learn to save your structure.
6. Use cron for content monitoring.

Example:

/learn how I create publish-ready SEO blog posts: keyword intent, reader pain, TL;DR, strong headings, examples, objections, FAQs, and final polish.

# Use Case 3: Coding Agent

Workflow:

1. Create a coder profile.
2. Add AGENTS.md to your repo.
3. Enable terminal and file tools.
4. Use checkpoints.
5. Use @diff for reviews.
6. Use subagents for research or refactors.

Example:

Review @diff for bugs, security issues, missing tests, and unclear code.

Turn on checkpoints:

hermes chat --checkpoints

Checkpoints can snapshot a project before risky file changes and restore with /rollback.

# Use Case 4: Operations Bot

Workflow:

1. Create an ops profile.
2. Run it on a VPS or Docker.
3. Connect Slack or Telegram.
4. Add safe monitoring scripts.
5. Use cron for checks.
6. Use hermes send for alerts.

Example:

hermes send --to slack:#ops --subject "[Server]" --file /tmp/report.md

Use this for clear, low-risk alerts before you let Hermes make changes.

# Use Case 5: Multi-Agent Workbench

Advanced users can use profiles, kanban, delegation, and background sessions.

Subagent delegation lets Hermes spawn child agents with isolated context and restricted toolsets. Each child agent gets only the goal and context passed to it, and only the final summary comes back to the parent.

Use this for:

• Parallel research
• Code review plus fix
• Multi-file refactors
• Independent checks
• Comparing options

Example:

Research three ways to build this feature. Delegate one agent to backend risks, one to frontend UX, and one to deployment concerns. Bring back a combined recommendation.

# The Safety Section Most Guides Skip

Hermes can be very useful.

It can also be risky.

That is not because Hermes is bad. It is because real agents can act. Any tool that can read files, run commands, use APIs, and remember things needs guardrails.

# Do These Things First

1. Use Docker, SSH, Modal, Daytona, or a VPS for risky work.
2. Keep approval prompts on.
3. Avoid /yolo unless the environment is disposable.
4. Limit tools per platform.
5. Use allowlists in messaging apps.
6. Review skills before trusting them.
7. Turn on memory and skill write approval if you want more control.
8. Use separate profiles for separate jobs.
9. Use checkpoints for code work.
10. Never give production access on day one.

# The Prompt Injection Problem

Persistent agents have a special risk: bad instructions can hide in memory, skills, files, web pages, messages, or scheduled jobs.

The right response is not panic.

The right response is structure.

Give Hermes limited access. Watch what it saves. Keep high-risk actions behind approval. Run dangerous tasks in sandboxes. Treat untrusted content as untrusted content.

# Common Hermes Agent Mistakes

# Mistake 1: Installing Everything Before Testing Anything

Do not start with MCP, five gateways, cron jobs, and custom skills.

Start with one clean chat.

# Mistake 2: Giving the Same Tools to Every Platform

Your local coding agent may need file and terminal tools.

Your public Discord bot probably does not.

# Mistake 3: Letting Memory Fill With Junk

Hermes memory is limited on purpose.

Save durable facts, not random chat notes.

# Mistake 4: Creating Skills Too Late

If you repeat a workflow twice, create a skill.

That is how Hermes compounds.

# Mistake 5: Using Profiles as Sandboxes

Profiles separate Hermes state.

They do not automatically limit filesystem access.

# Mistake 6: Automating Too Early

If Hermes cannot do the task well by hand, do not schedule it.

A weak manual workflow becomes a worse scheduled workflow.

# Hermes Agent Mastery Checklist

You are no longer a beginner when you can:

• Install Hermes
• Configure a model
• Run hermes doctor
• Resume sessions
• Use /status, /new, /resume, and /compress
• Add project context with AGENTS.md
• Use @file, @diff, @folder, and @url
• Create skills with /learn
• Review skills with /skills
• Control memory with /memory
• Set up a messaging gateway
• Use /sethome
• Use /handoff
• Create cron jobs
• Use toolsets safely
• Configure MCP with filters
• Use profiles for separate agents
• Enable checkpoints for code work
• Use /goal, /background, and /steer
• Avoid unsafe /yolo habits
• Design workflows that improve over time

# Direct answer

Hermes Agent is an open-source autonomous AI agent from Nous Research that you operate, not just chat with. To go from beginner to advanced, install it, connect one stable model, and confirm you can chat and resume a session. Then add memory through MEMORY.md and USER.md, turn repeat work into skills with /learn, connect a messaging gateway like Telegram or Slack, schedule low-risk tasks with cron, add MCP tools, and split jobs across profiles. Throughout, keep it safe with sandboxes, approval prompts, allowlists, and limited tools per platform. Start small, teach it clearly, and automate only what already works by hand.

# FAQ

# Is Hermes Agent just another chatbot?

No. A chatbot mainly replies. Hermes can use tools, remember useful facts, create skills, run commands, work through messaging platforms, and schedule tasks.

# Is Hermes Agent beginner-friendly?

It can be beginner-friendly if you follow the right order. Start with chat, then memory, then skills, then gateways, then automation. Do not start with every advanced feature at once.

# What is the /learn command in Hermes Agent?

/learn lets Hermes create a reusable skill from a source you provide. That source can be a URL, folder, docs, notes, or a workflow you just walked through.

# What is the best first Hermes Agent use case?

The best first use case is a low-risk repeat task. Examples include daily research, content briefs, repo summaries, or status reports.

# Can Hermes Agent run on my phone?

Hermes can be used from messaging apps on your phone. It can also run in Termux on Android, but most users will have a better experience running Hermes on a machine or server and talking to it through a gateway.

# Should I use Hermes Agent with production systems?

Not at first. Start in a sandbox. Use approvals. Limit tools. Prove the workflow. Then add access slowly.

# What is the safest way to use Hermes Agent?

Use a separate profile, a sandboxed backend, limited toolsets, command approvals, messaging allowlists, and skill or memory write approval for sensitive workflows.

# Final Verdict

Hermes Agent is not just another AI chatbot.

It is a framework for building a personal AI operator that can remember, learn, act, automate, and meet you where you work.

The beginner uses Hermes to answer questions.

The intermediate user gives Hermes context, tools, and skills.

The advanced user builds separate profiles, connects messaging gateways, schedules repeat work, uses MCP, reviews memory, controls permissions, and turns repeated processes into durable skills with /learn.

That is the real path from beginner to master:

Start small. Teach it clearly. Give it the right tools. Limit its access. Turn repeat work into skills. Automate only what already works.

Do that, and Hermes becomes more than a smart assistant.

It becomes a system that gets better with you.

# Sources

• Hermes Agent documentation
• Hermes Agent GitHub repository
• Hermes Agent command reference
• Hermes Agent slash commands reference
• Hermes Agent Desktop app guide
• Hermes Agent memory guide
• Hermes Agent skills guide
• Hermes Agent security guide
• Sleeper Channels and Provenance Gates: Persistent Prompt Injection in Always-on Autonomous AI Agents

# Use and trademark notes

This article is educational and is not affiliated with, endorsed by, or sponsored by Nous Research.

Hermes Agent is open-source software. Commands, features, and install steps can change between releases. Confirm current details in the official documentation before you install or automate.

Run agents with real tool access carefully. Use sandboxes, approvals, allowlists, and limited permissions, especially before connecting production systems.

Hermes Agent, Nous Research, and other product names are trademarks of their respective owners.