Build Hermes AI Agent: VPS Setup to Scaled Automations

Hermes Core: Five Pillars for Self-Improving Agents

Hermes Agent, an open-source project from Noose Research with 140k+ GitHub stars (MIT licensed), runs on your infrastructure (VPS, laptop, Docker, even Android via Termux). It excels at self-improvement via a loop that persists experience into memory, skills, and history. Unlike stateless LLMs, Hermes wakes with context from key files, enabling consistent, personalized behavior.

The five pillars form its foundation:

1. Memory: Durable context across sessions via user.md (your preferences, style) and memory.md (projects, business context). Loaded at session start. Use session search (SQLite DB) for past conversations. Principle: Agents are amnesiac like in Memento—feed holistic context upfront. Hermes auto-extracts/updates these; manually reinforce with "Chuck this into memory.md" or "Never do X again—add to user.md". Avoid secrets or temp status here.
2. Skills: Procedural playbooks in skills.md with YAML frontmatter for progressive disclosure (e.g., ```yaml when_to_use: "For image generation"

3. **Soul**: Shapes personality in `soul.md` (no YAML). Evolves with feedback for vibe (e.g., sarcastic but not rude for YouTube comments). Makes multi-agents distinct.

4. **Crons**: Proactive scheduling turns reactive agent into autonomous worker. Natural language: "Daily 6AM briefing." Creates isolated sessions; outputs to original chat/files. Flags: `context_from` chains jobs, `work_dir` for project tools, `--no-agent` for scripts. Safety: No recursive crons—prompts must be self-contained.

5. **Self-Improving Loop**: Work → Learn → Persist (memory/skills/history) → Repeat. User corrects, saves, skill-ifies. Not magic—guide it.

Bonus: `agents.md` (global project goals, like Claude's `claw.md`). Use for multi-project terminal work.

**Common Mistake**: Overloading context—keep files lean; let progressive disclosure handle skills. **Quality Check**: Does it repeat itself? Update memory. Feels impersonal? Tune soul.

## Deployment: VPS Setup and Telegram Onboarding

Assumes basic terminal comfort (SSH, git). No Mac Mini needed—use Hostinger VPS (code NATEHERK for 10% off annual).

### Step 1: VPS Provisioning (16:30 timestamp)
- Sign up Hostinger VPS (Ubuntu 24.04 recommended, 2-4 vCPU, 4-8GB RAM for Hermes).
- SSH in: `ssh root@your-ip`.
- Update: `apt update && apt upgrade -y`.
- Install Docker: `curl -fsSL https://get.docker.com -o get-docker.sh && sh get-docker.sh`.
- Add user: `adduser hermes && usermod -aG sudo,docker hermes`.
- Firewall: `ufw allow OpenSSH && ufw allow 80,443 && ufw enable`.

### Step 2: Hermes Install
- Switch to hermes user: `su - hermes`.
- Clone repo: `git clone https://github.com/NooseResearch/Hermes.git && cd Hermes`.
- Docker compose: Edit `docker-compose.yml` for models (e.g., Claude via API keys), volumes.
- Secrets: Use `.env` for API keys (Anthropic, etc.)—**never** in memory files.
- Start: `docker compose up -d`.

### Step 3: Telegram Integration (25:30)
- Create Telegram bot via @BotFather: Get token.
- In Hermes web UI (http://your-ip:3000), onboard: Paste bot token, chat ID (msg /start to bot, copy ID).
- Test: Message bot—Hermes responds.

Hermes auto-builds initial `user.md`/`memory.md` from chats. **Pitfall**: Expose only necessary ports; use Cloudflare Tunnel for security.

## Skills, Crons, Backup, and Scaling

### First Skill and Cron (33:00)
- **Skill Example**: Paste Skills Hub URL: "Install this generate-image skill."
- YAML frontmatter ensures targeted loading.
- **First Cron**: "Create daily AI news briefing to Skool at 6AM." Hermes crafts cron.yaml, schedules via tools.

### GitHub Backup (33:00)
- Init repo: `git init`, add all (`git add .`), commit, remote: `git remote add origin your-repo`.
- Cron backup: "Daily GitHub push."
- **Pro Tip**: Use Claude Code to manage multi-agent repos—sync skills/memory across Hermes/OpenClaw.

### Best Practices & Security (46:30)
- **Security**: API keys in `.env` only. Rate limits. No recursive crons. Isolate agents in subdirs.
- **DX**: Terminal for deep work (Claude Code better); Telegram for mobile/proactive.
- **Trade-offs**: Lighter/faster than OpenClaw (350k stars, Nvidia NemoClaw fork); less breakage. Not for desk coding—pair with Claude.

### Scaling Multiple Agents (50:30)
- Subdirs per agent: `agents/yt-comments`, `agents/news`.
- Shared GitHub repo; distinct `soul.md`/`memory.md`.
- VPS: Multiple Docker instances or subdomains.
- **Pitfall**: Context bloat—use `agents.md` for project silos.

**Before/After**: Raw request → poor video (bad spacing); feedback → Hyperframes install, polished output.

**Exercise**: Install Excalidraw skill, generate pillar diagrams: "Use Excal to diagram five pillars."

## Comparisons and Workflow Fit

| Tool | Use Case | Why Hermes? |
|------|----------|-------------|
| Claude Code | Desk/terminal coding (90% Nate's work) | Mobile, crons unlimited vs 15/day limit |
| OpenClaw | Similar mobile, but heavier/breaks more | Lighter, self-improving, OSS models ready |

Fits indie builders: On-the-go automations (YouTube replies, news briefs) without infra always-on.

**Quotes**:
1. "Hermes probably understands it the best and it can also look up its own documentation so just ask it hey can you do this." (On troubleshooting.)
2. "Memory equals what to remember, skill equals how to do it again." (Pillar distinction.)
3. "Crons turn Hermes from reactive into a proactive scheduled automation." (Key value prop.)
4. "Automatic does not mean magic—the loop works best when the user corrects Hermes." (Self-improvement reality check.)

## Key Takeaways
- Start with VPS (Hostinger Ubuntu), Docker install Hermes, Telegram bot for instant access.
- Prime memory/soul files early; let Hermes auto-update but manually reinforce.
- Build skills via hub or convos; use YAML for efficiency.
- Schedule crons in natural language—self-contained prompts only.
- GitHub backup everything; scale via subdirs for multi-agents.
- Pair with Claude Code: Hermes for mobile/proactive, Claude for deep work.
- Avoid: Secrets in MD files, recursive crons, ignoring feedback loops.
- Test: Natural request → skill install → cron → iterate.
- Resource: Free Skool guide for copy-paste setup.