---
title: Hermes Agent: The Self-Learning AI That Builds Its Own Automations — Setup, Use, and Monetize
description: Practical guide to Hermes Agent: install in 1 minute, interact via terminal TUI, let the agent create automations automatically, monetize with Telegram bots.
date: 2026-04-09
url: https://caminhosolo.com.br/en/2026/04/hermes-agent-setup-automations/
tags: [ai-agents, automation, open-source, hermes-agent, solo-builder, practical-ai, self-improving]
---


## TL;DR

Hermes Agent is an open-source AI agent that runs as a terminal interface (TUI) and **automatically learns from every conversation you have**. Install in one command line, chat naturally, let the agent build its own automations. Works with 200+ AI models (OpenAI, Claude, Mistral, local). Connect via Telegram for always-on access. Core difference from [OpenClaw](/2026/03/openclaw-agente-ia-pessoal-solopreneur): Hermes creates automations autonomously without you writing code. Monetize by selling specialized bots via Telegram.

---

The agent ecosystem shifted. It's no longer about building complex systems — it's about **talking to an agent that thinks, learns, and improves on its own**.

Hermes Agent (from Nous Research) represents this shift. You don't program. You converse. The agent watches your complex tasks and **automatically builds reusable automations**.

If you're a solo builder who wants a system that:
- Learns from your actual work
- Creates automations without code
- Runs 24/7 on a $5 VPS
- Monetizes via Telegram bots

Hermes is exactly what you need.

This guide is practical. Real installation (1 minute). Real usage (you talk). Real monetization.

---

## Why Hermes Changes Everything (And How It Differs from OpenClaw)

Six months ago, AI agents required complex configuration. You'd define workflows, write code, integrate APIs.

Hermes inverts that. It:

- **Learns from conversations**: complex tasks automatically become reusable skills
- **Improves with use**: skills evolve on their own as you use them
- **Runs anywhere**: $5 VPS, GPU cluster, serverless
- **Supports 200+ models**: OpenAI, Claude, Mistral, local models, OpenRouter
- **Native Telegram integration**: always-on access, no terminal required
- **Persistent memory**: learns about you and your patterns over time

Quick comparison with [OpenClaw](/2026/03/openclaw-agente-ia-pessoal-solopreneur):

| Feature | Hermes | OpenClaw |
|---------|--------|----------|
| Interface | Terminal TUI (conversational) | Task-oriented |
| Skill Creation | Automatic from conversations | You configure |
| Learning | Continuous | Per-session |
| Easiest setup | 1 line (curl) | Multiple steps |
| Monetization | Native Telegram bots | Requires integration |
| Memory | Persistent + searchable | Contextual |

[OpenClaw](/2026/03/openclaw-agente-ia-pessoal-solopreneur) is solid. Hermes is **for builders who want less overhead and more automatic learning**.

---

## Setup in 1 Minute (Seriously)

### Installation

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

Done. It's working.

The script installs:
- Python and Node.js (if needed)
- All dependencies
- Hermes CLI

You now have a functional agent.

### First Use

```bash
hermes
```

You'll see a clean TUI:

```
Hermes Agent v0.2.x
Type your message or /help for commands

hermes> 
```

Chat naturally:

```
hermes> what tools do you have access to?
```

**Hermes lists 40+ integrated tools.**

```
hermes> find recent news about AI agents
```

**Hermes executes search, summarizes, saves to memory.**

```
hermes> analyze this email and suggest a response
```

**Hermes reads it, suggests actions.**

Press `Ctrl+C` to exit.

---

## How Hermes Actually Works (The Mental Model)

Hermes isn't a program you customize with code. It's **an agent you converse with that learns**.

### Here's the flow:

1. **You chat normally** — ask for complex things
2. **Hermes executes** — uses tools, APIs, processes data
3. **Learns automatically** — detects repetitive patterns
4. **Creates skills** — when it identifies a recurring task
5. **Improves over time** — better with each use

### Real example:

**Day 1:**
```
hermes> search for recent news about startups, summarize in 5 bullet points
```
Hermes searches and summarizes.

**Day 2:**
```
hermes> get startup news summary, 5 points
```
Hermes recognizes the pattern. Internally creates the skill `startup_news_summary`.

**Day 3:**
```
hermes> /startup_news_summary
```
Hermes executes the skill instantly. Refined. Fast.

You **wrote zero code**. The agent learned by watching.

---

## The Critical Difference vs OpenClaw

OpenClaw you **configure**. Hermes you **use**.

**OpenClaw:**
- You define workflows
- You integrate APIs
- You manage behavior

**Hermes:**
- You converse
- Hermes observes
- Hermes learns and creates automations

Analogy: OpenClaw is like programming a robot. Hermes is like mentoring an assistant.

---

## Commands You Actually Use

**In the TUI (terminal, during chat):**

| Command | What it does |
|---------|--------------|
| `/new` or `/reset` | Start fresh conversation |
| `/model gpt-4-turbo` | Switch AI model |
| `/personality analyst` | Set agent personality |
| `/skills` | List skills Hermes created |
| `/skill_name` | Execute a skill |
| `/compress` | Summarize long conversation |
| `/usage` | Show token usage |

**Outside TUI (setup):**

```bash
hermes model                    # Select which LLM to use
hermes tools                    # Configure which tools to enable
hermes config set               # Adjust settings
hermes gateway                  # Start Telegram/Discord/Slack gateway
hermes setup                    # Complete setup wizard
hermes doctor                   # Debug issues
```

**Real-world usage example:**

```bash
hermes
```

```
hermes> what are my most important leads this week?
```

Hermes accesses your CRM (if configured), analyzes, shows priority leads.

```
hermes> create an automation that sends me this every Monday
```

Hermes identifies the pattern, builds the automation. Now `/weekly_leads` exists.

```
hermes> /weekly_leads
```

Runs instantly.

---

## Real Configuration (What Actually Changes)

You **don't manually edit config files**. You run:

```bash
hermes setup
```

Interactive wizard:

1. **Choose your model**: OpenAI? Claude? Mistral local?
2. **Choose provider**: OpenRouter (200+ models), OpenAI, Anthropic, or local
3. **Set API key**: in `.env` or environment variables
4. **Select tools**: web search, email, code execution, database access?
5. **Define personality**: "you're a marketing expert" or custom

Done. Hermes is configured.

### Switch models later:

```
hermes> /model openrouter:claude-opus
```

Switches instantly. No restart. No code changes.

### Telegram Setup (Critical for Monetization)

```bash
hermes gateway
```

Starts the "gateway" — a process connecting Hermes to Telegram, Discord, Slack, WhatsApp, Signal simultaneously.

**Setup:**
1. Create bot at [@BotFather](https://t.me/botfather) — get token
2. Configure in Hermes: `hermes config set telegram_token "your_token"`
3. `hermes gateway` — now your bot responds on Telegram
4. Message your bot — all skills work there

---

## Using Hermes in Practice (Real Cases)

### Case 1: Content Research Assistant

**You do:**
```
hermes> find best practices for SaaS marketing in 2026 (last 30 days only)
```

**Hermes:**
- Searches recent data
- Analyzes patterns
- Returns structured summary
- **Learns**: now knows you care about SaaS marketing

**Next time:**
```
hermes> /saas_market_research
```

Runs automatically. Hermes built the skill itself.

### Case 2: Lead Follow-up Manager

**You do:**
```
hermes> connect to my Pipedrive, show leads not contacted in 5+ days
```

**Hermes:**
- Accesses API
- Queries leads
- Filters
- Returns list

**You say:**
```
hermes> automate this check every morning at 8am
```

**Hermes creates the skill** with scheduling.

**Now exists:**
```
/daily_stale_leads
```

Runs automatically.

### Case 3: Editorial Assistant

**You do:**
```
hermes> review this article and suggest 3 better angles for solo builders
```

Hermes reads, analyzes, suggests angles.

**You:**
```
hermes> refine angle 2 with focus on monetization
```

**Hermes improves the analysis.**

**Later:**
```
hermes> /article_reviewer
```

The skill is built. Runs for new articles automatically.

---

## Memory and Learning (How Hermes Actually Learns)

Hermes isn't forgetful. It:

- **Saves all conversations**: searchable via LLM ("when did I mention X?")
- **Learns your patterns**: identifies tasks you repeat
- **Builds a profile**: knows your interests, preferences, style
- **Creates skills**: when it spots recurring patterns
- **Refines skills**: each use improves the automation

**How to access:**

```
hermes> summarize what we talked about regarding marketing
```

Hermes accesses history, analyzes, summarizes marketing discussions.

```
hermes> what skills did I create about SEO?
```

Lists them.

```
hermes> show history of /seo_audit skill
```

Shows every use, how it evolved.

---

## Telegram Integration (Your Always-On Interface)

Why Telegram? Because:

- **Always in your pocket**: phone is always with you
- **No overhead**: no laptop, no dashboard
- **Monetizable**: sell access to private specialized bots
- **Multi-platform**: same bot on Telegram, Discord, Slack

### Telegram setup:

**1. Create bot:**
- Open Telegram
- Search @BotFather
- `/newbot`
- Choose name and username
- Receive token

**2. Connect Hermes:**

```bash
hermes gateway
```

(You'll be prompted for token during setup)

**3. Use:**
- Message bot: "what's my lead summary today?"
- Hermes responds
- All skills work there

```
@yourbot hey, run /weekly_report
```

Executes the skill via Telegram.

---

## Monetization (Why Hermes is a Revenue Machine)

Hermes enables 5 practical revenue models:

### Model 1: Specialized Paid Bot

Train Hermes for a niche. Charge access. This approach works perfectly for creating [micro-SaaS](/2026/03/micro-saas-sem-programar) products that generate recurring revenue.

**Examples:**
- **Business Validation Bot**: $29/month — analyze product ideas for viability
- **Marketing Analysis Bot**: $49/month — review campaigns, suggest improvements
- **SEO Audit Bot**: $99/month — analyze content, create SEO strategy

**How to monetize:**
```
- Create Telegram bot
- Configure Hermes with custom personality
- Set up Stripe payment
- Add users → they get private bot token
- Bot runs on your $5 VPS
```

With 50 users at $29/month = $1,450/month.

### Model 2: Automation Consulting

Install Hermes at companies, train them, charge:

- **Setup + Training**: $2,000–5,000
- **Monthly Maintenance**: $500–1,000/month

Each client gets a customized Hermes on their VPS.

### Model 3: Sell Custom Skills

Once Hermes builds a powerful skill, you:

1. Extract it
2. Sell as "plugin" ($99–299 one-time or $9/month)
3. Customers install on their own VPS

**Examples:**
- Shopify integration skill
- Google Sheets data analysis skill
- Email summarization skill

### Model 4: Bot Platform as a Service

Offer "Hermes as a Service" — essentially a [micro-SaaS](/2026/03/micro-saas-sem-programar) where customers use specialized bots:

- Customers choose specialist type
- You run on your infrastructure
- Charge per API call or subscription

**Pricing**: $0.10 per request or $99/month unlimited.

1,000 requests/day = $3,000/month.

### Model 5: Private Community

Create paid Telegram group, your bot specializes there:

- Entrepreneur group: bot analyzes business ideas
- Creator group: bot helps generate content ideas
- Developer group: bot debugs code

Charge group access: $49–199/month.

Hermes works in background, you don't.

---

## Hermes vs OpenClaw (When to Use Each)

Both excellent. Different use cases.

### Use Hermes when:

✅ Want maximum simplicity (1-minute install)  
✅ Prefer conversation over configuration  
✅ Want monetizable Telegram bot  
✅ Need automatic learning  
✅ Like multiple model options (200+)  

### Use OpenClaw when:

✅ Want polished web interface  
✅ Need highly customized workflows  
✅ Want large ecosystem and community  

### Hybrid strategy:

Many builders use **both**:
- Hermes for monetized Telegram bot
- [OpenClaw](/2026/03/openclaw-agente-ia-pessoal-solopreneur) for rapid prototyping
- Hermes for self-improving automation

---

## Next Steps

1. **Install Hermes** (1 minute):
```bash
curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash
source ~/.bashrc
hermes
```

2. **Chat with Hermes** (30 minutes) — watch skills being created

3. **Choose your AI model** (OpenAI, Claude, or local Mistral):
```bash
hermes setup
```

4. **Use for 1 week** — observe patterns and automatic skill creation

5. **Pick monetization** — which model fits you?

6. **Connect Telegram** — your always-on interface:
```bash
hermes gateway
```

Then you have a system that:
- Learns from your work
- Builds automations autonomously
- Generates passive revenue

**Hermes isn't a tool you use. It's an assistant you build with.**

Start today.

