Hermes Agent auf einem Hostinger­-VPS installieren

Was du vorab brauchst

Bevor du den ersten Befehl tippst, halte drei Dinge bereit. Erstens: Einen SSH-Client. Auf macOS und Linux liegt der bereits im System (Terminal). Auf Windows empfiehlt sich Windows Terminal mit OpenSSH oder die exzellente PuTTY-Suite. Zweitens: Einen API-Key deines bevorzugten LLM-Anbieters – am einfachsten Anthropic Claude (console.anthropic.com) oder OpenAI (platform.openai.com). Lege beim ersten Mal ein Budget-Limit von 10–20 € fest, das schützt vor Überraschungen, falls du in der Lernphase einen Endlos-Loop produzierst. Drittens: Ein Telegram-Konto, weil wir den Agenten standardmäßig über Telegram steuern werden.

Plane für die initiale Einrichtung dreißig bis vierzig Minuten ein. Wer schneller ist, hat etwas übersprungen, das später beißen wird – Sicherheits- und Backup-Konfigurationen sind keine Optionalitäten, sie sind Teil der Grundinstallation.

Schritt 1 — Hostinger-VPS bestellen

Öffne die Hostinger-VPS-Seite und wähle den Plan KVM 2 (€8,99/Monat im Einführungspreis). Dieser Plan bietet 2 vCPU, 8 GB RAM und 100 GB NVMe-SSD – mehr als ausreichend für eine Hermes-Installation mit drei bis vier parallelen Sub-Agenten und Docker-Sandbox.

Im Bestellprozess wirst du nach mehreren Konfigurationen gefragt:

• Standort: wähle Frankfurt oder Litauen, beides EU-DSGVO-konform und mit guter DACH-Latenz.
• Betriebssystem: Ubuntu 24.04 LTS. Long-term Support bis 2029, aktuelle Pakete, große Community.
• Hostname: beliebig, etwa agent-vps.
• Root-Passwort: generiert oder selbst gewählt; mindestens 16 Zeichen, gemischt.
• SSH-Key: wenn schon vorhanden, jetzt hinterlegen. Sonst per Passwort einloggen und später hinzufügen.

Nach Abschluss der Bestellung dauert die Bereitstellung typischerweise 60–120 Sekunden. Du erhältst eine E-Mail mit IPv4-Adresse, Hostnamen und Zugangsdaten.

Schritt 2 — Server härten

Bevor du Software installierst, solltest du deinen Server gegen die häufigsten Angriffsvektoren schützen. Drei Maßnahmen reichen für 95 % der Fälle: SSH-Key-Login statt Passwort, ufw-Firewall mit Default-Deny, fail2ban gegen Brute-Force-Versuche.

SSH-Key statt Passwort

Auf deinem lokalen Rechner (falls noch nicht geschehen):

$ ssh-keygen -t ed25519 -C 'agent-vps'
$ ssh-copy-id root@DEINE-IP

Dann auf dem Server Passwort-Login deaktivieren:

root@vps:~$ sed -i 's/^#\?PasswordAuthentication.*/PasswordAuthentication no/' \
                /etc/ssh/sshd_config
root@vps:~$ systemctl restart ssh

Firewall mit ufw

root@vps:~$ ufw default deny incoming
root@vps:~$ ufw default allow outgoing
root@vps:~$ ufw allow 22/tcp
root@vps:~$ ufw enable
root@vps:~$ ufw status verbose

Brute-Force-Schutz mit fail2ban

root@vps:~$ apt install -y fail2ban
root@vps:~$ systemctl enable --now fail2ban

Mit Default-Konfiguration sperrt fail2ban nach fünf fehlgeschlagenen SSH-Versuchen die Quell-IP für zehn Minuten. Reicht für die meisten Szenarien.

Schritt 3 — Abhängigkeiten installieren

Hermes braucht Python 3.11, Node.js, ripgrep, ffmpeg und Git. Auf Ubuntu 24.04 sind die meisten in den Standard-Repositories verfügbar.

root@vps:~$ apt update && apt -y upgrade
root@vps:~$ apt install -y python3.11 python3.11-venv python3-pip \
                ripgrep ffmpeg git curl ca-certificates gnupg
root@vps:~$ curl -fsSL https://deb.nodesource.com/setup_22.x | bash -
root@vps:~$ apt install -y nodejs

Schritt 4 — Hermes Agent installieren

Das offizielle Install-Skript erkennt das System, prüft Versionen und legt alle Verzeichnisse an. Es lebt im offiziellen GitHub-Repository NousResearch/hermes-agent.

root@vps:~$ curl -fsSL raw.githubusercontent.com/NousResearch/hermes-agent/.../install.sh | bash
  ▸ Detecting OS… Ubuntu 24.04
  ▸ Python 3.11 ✓
  ▸ Node.js 22 ✓
  ▸ Cloning hermes-agent…
  ▸ Creating venv at ~/.hermes/venv
  ▸ Installing dependencies…
  ✓ Hermes v0.13.0 installed
  ▸ Run 'hermes setup' to start configuration.
root@vps:~$ source ~/.bashrc
root@vps:~$ hermes --version
hermes 0.13.0

Schritt 5 — Setup-Wizard durchlaufen

Mit hermes setup startet ein interaktiver Wizard:

root@vps:~$ hermes setup

▸ Welcome to Hermes Agent v0.13

  Step 1/5: LLM Provider
    [1] Anthropic Claude  (recommended)
    [2] OpenAI GPT
    [3] Local via Ollama
    [4] Nous Hermes 4
  > 1
  Enter API key: sk-ant-api03-************

  Step 2/5: Default Model
    [1] claude-sonnet-4-6  (balanced, recommended)
    [2] claude-opus-4-7    (highest quality)
    [3] claude-haiku-4-5   (fastest, cheapest)
  > 1

  Step 3/5: Sandbox Backend
    [1] local       (no isolation)
    [2] docker      (recommended)
    [3] ssh         (for advanced setups)
  > 2

  Step 4/5: Tools to enable
    [x] web_search
    [x] browser
    [x] shell
    [x] file_io
    [ ] vision         (enable? y/N) y
    [ ] image_gen      (enable? y/N) n
    [ ] tts            (enable? y/N) n

  Step 5/5: Approval mode
    [1] Always ask before write actions  (recommended)
    [2] Auto-approve safe actions
    [3] Full auto (advanced)
  > 1

✓ Configuration written to ~/.hermes/config.yaml

Der Wizard erzeugt eine YAML-Konfiguration, die du jederzeit per Texteditor oder mit hermes config set anpassen kannst.

Schritt 6 — Docker-Sandbox aktivieren

Damit das Sandbox-Backend tatsächlich nutzbar wird, muss Docker installiert sein. Wir nutzen das offizielle Docker-Repository, weil die Ubuntu-Standardpakete oft hinterherhinken.

root@vps:~$ install -m 0755 -d /etc/apt/keyrings
root@vps:~$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg \
                -o /etc/apt/keyrings/docker.asc
root@vps:~$ chmod a+r /etc/apt/keyrings/docker.asc
root@vps:~$ echo 'deb [arch=amd64 signed-by=/etc/apt/keyrings/docker.asc] \
                https://download.docker.com/linux/ubuntu noble stable' \
                > /etc/apt/sources.list.d/docker.list
root@vps:~$ apt update && apt install -y docker-ce docker-ce-cli containerd.io
root@vps:~$ docker run --rm hello-world
Hello from Docker! ✓

Schritt 7 — Telegram-Bot anbinden

Öffne in Telegram einen Chat mit @BotFather. Schreibe /newbot, folge den Anweisungen, gib deinem Bot einen Namen (Anzeigename) und einen Username (muss auf _bot enden, etwa fra_agent_bot). Du erhältst einen Token im Format 123456789:ABCdef…. Kopiere ihn.

Außerdem brauchst du deine eigene Telegram-User-ID. Schreibe an @userinfobot, er antwortet mit deiner numerischen ID. Diese setzen wir als Whitelist.

root@vps:~$ hermes gateway setup
▸ Configure messaging gateways

  Available platforms:
    [x] Telegram     (configure now)
    [ ] Discord      (skip)
    [ ] Slack        (skip)
    [ ] WhatsApp     (skip)
    [ ] Signal       (skip)

  ▸ Telegram bot token: 123456789:ABCdef************
  ▸ Allowed user IDs (comma-separated): 987654321
  ▸ Bot display name: fra-agent
  ▸ Persistent memory per user? (Y/n) Y

✓ Telegram gateway configured
  Run 'hermes gateway start' to launch.

Probelauf:

root@vps:~$ hermes gateway start
  ▸ Starting gateway on :18789
  ▸ Telegram polling… connected as @fra_agent_bot
  ▸ Heartbeat: every 60s
  ✓ Ready. Send a message to your bot.

Schreibe in Telegram an deinen neuen Bot: „Hallo, wer bist du?“ – und du solltest binnen weniger Sekunden eine Antwort bekommen. Beende den Vorder­grund­prozess mit Strg+C, wir verwandeln ihn gleich in einen Hintergrund-Service.

Schritt 8 — Als systemd-Service starten

Damit der Agent Reboots überlebt, registrieren wir ihn als systemd-Unit. Lege folgende Datei an:

root@vps:~$ nano /etc/systemd/system/hermes.service

[Unit]
Description=Hermes Agent Gateway
After=network.target docker.service
Requires=docker.service

[Service]
Type=simple
User=root
WorkingDirectory=/root
ExecStart=/root/.hermes/venv/bin/hermes gateway start
Restart=on-failure
RestartSec=10
StandardOutput=append:/var/log/hermes.log
StandardError=append:/var/log/hermes.err.log

[Install]
WantedBy=multi-user.target

root@vps:~$ systemctl daemon-reload
root@vps:~$ systemctl enable --now hermes
root@vps:~$ systemctl status hermes
  ● hermes.service - Hermes Agent Gateway
     Loaded: loaded (/etc/systemd/system/hermes.service)
     Active: active (running) since 2026-05-09 14:22:18 CET

Schritt 9 — Monitoring & Logs

Drei Befehle reichen für den Alltag:

• journalctl -u hermes -f — Live-Stream der Logs.
• systemctl status hermes — schneller Health-Check.
• hermes doctor — diagnostiziert Konfigurationsprobleme, prüft API-Connectivity, listet aktive Skills.

Für ernstes Monitoring – etwa wenn du den Agenten kommerziell betreibst – empfehlen wir Uptime-Kuma als Dashboard, plus Healthcheck.io oder einen Telegram-Watchdog-Bot, der dir Alarm schlägt, wenn der Hauptagent länger als fünf Minuten still ist. Hostinger selbst zeigt im Panel Server-Metriken (CPU, RAM, Netzwerk) in Echtzeit.

Schritt 10 — Häufige Probleme lösen

Der Telegram-Bot antwortet nicht

Prüfe drei Dinge in dieser Reihenfolge: (1) Läuft der Service? systemctl status hermes. (2) Ist deine User-ID auf der Whitelist? cat ~/.hermes/config.yaml | grep allowed_users. (3) Hast du den Bot in Telegram tatsächlich gestartet? Klick auf „Start“ im Bot-Chat ist Pflicht beim ersten Kontakt.

API-Key wird abgelehnt

Anthropic-Keys beginnen mit sk-ant-api03-, OpenAI mit sk-. Achte auf Copy-Paste-Fehler – ein einziges Leerzeichen zerstört den Key. hermes doctor testet die Verbindung explizit.

Docker-Container starten nicht

Stelle sicher, dass der Docker-Daemon läuft: systemctl status docker. Auf Hostinger-VPS kommt es selten vor, aber wenn das Subsystem nicht initialisiert wurde, hilft ein systemctl restart docker. Prüfe zudem, ob dein User in der Gruppe docker ist (bei root nicht relevant): id.

Out-of-Memory auf KVM 1

Wenn dein Agent regelmäßig durch OOM-Killer beendet wird, hast du den falschen Plan gewählt. Hermes mit Docker-Sandbox und ein paar Sub-Agenten will 6–8 GB RAM sehen. Upgrade auf KVM 2 oder schalte Docker-Sandbox aus (sandbox: local) – auf eigene Verantwortung.

Agent „halluziniert“ Aktionen

Im Approval-Mode passiert das nicht – jede Aktion fragt vor Ausführung nach. Wenn du das Verhalten auch ohne Approval-Mode reduzieren willst: System-Prompt schärfen (~/.hermes/config.yaml → system_prompt), Tools deaktivieren, die du nicht brauchst (hermes tools), oder das Modell auf Sonnet/Opus statt Haiku umstellen – größere Modelle halluzinieren weniger.

Wie es weitergeht

Damit ist die Grundinstallation abgeschlossen. Im nächsten Schritt empfehlen wir dir:

1. Skills entdecken: Schau in der Hermes-Doku unter „Skills“, welche fertigen Workflows mitkommen. Cron-Jobs in natürlicher Sprache („Schicke mir jeden Montag um 9 Uhr einen Status-Bericht von github.com/xy“) sind ein guter Einstieg.
2. Sub-Agenten erforschen: Mit hermes agent spawn startest du parallele Konversationen, die im Hintergrund länger laufende Tasks abarbeiten – Recherche, Datenextraktion, Code-Review.
3. Slack/Discord ergänzen: hermes gateway setup erlaubt dir jederzeit, weitere Plattformen anzubinden. Telegram für Privates, Slack für Arbeit, Discord für die Community.
4. Modal-Sandbox ausprobieren: Wenn du gelegentlich GPU-Workloads (Bildgenerierung, lokale Modelle, Vision) brauchst, hänge Modal als Sandbox-Backend an. Pay-per-Second-Compute, läuft komplett transparent für den Hauptagenten.
5. Backups testen: Spätestens nach einer Woche – stelle einen Snapshot wieder her, um zu prüfen, dass dein Backup-Pfad funktioniert. Ungetestete Backups sind keine Backups.

Wenn du parallel OpenClaw ausprobieren möchtest, geht das auf demselben Server – die Setups beißen sich nicht. Den ausführlichen Direktvergleich findest du in einer eigenen Übersicht. Fragen, Anregungen, Bug-Reports? Die offizielle Nous Research Discord-Community ist sehr aktiv und antwortet meist innerhalb weniger Stunden.