Self-host Hermes Agent on a Netcup VPS — an AI agent that stays on

TL;DR: Running Hermes Agent on Netcup in 5 minutes

Self-host Hermes Agent on a Netcup VPS and the agent stops being a terminal you have to keep open. It runs as a service, keeps its memory and skills on disk, and answers you from Telegram or Discord while your laptop is shut. Hermes Agent is Nous Research's MIT-licensed, self-improving agent — the one that writes its own skills as it works and recalls them in the next session.

• Self-improving loop — the agent curates its own memory files, extracts reusable patterns, and writes them back as skills it can load later. Nothing about that survives if the process lives on a laptop that sleeps.
• 20+ messaging platforms from one gateway — Telegram, Discord, Slack, WhatsApp, Signal, Matrix, Mattermost, email, SMS and more, all sharing one memory store.
• Python 3.14 plus a managed toolchain — Node.js, ripgrep, FFmpeg and a pinned Chromium are installed by the project's own package manager, not your distro's.
• Seven terminal backends — local, Docker, SSH, Daytona, Singularity, Modal and Vercel Sandbox. On a server you want the Docker one.
• Built-in cron — scheduled jobs that deliver their output straight into a chat, which is the entire reason an always-on box pays for itself.
• MIT licensed, bring your own model — Nous Portal, OpenRouter, OpenAI, Anthropic, Google, Bedrock, or any OpenAI-compatible endpoint. The software costs nothing; inference is billed by whoever you point it at.

curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
source ~/.bashrc
hermes setup --portal      # or: hermes model, to wire up your own provider key
hermes gateway setup       # connect Telegram, Discord, Slack
hermes gateway install     # install the systemd user service

Primary pick: VPS 1000 G12.5 — 4 vCore, 8 GB ECC RAM, 128 GB SSD, around €12/month excl. VAT.

• First month free: 6877nc17911959132
• Second code: 6877nc17911959130
• Third code: 6877nc17912005430

Introduction

An agent that learns from what it did yesterday is a different product from one that doesn't, and the difference only shows up over weeks. Hermes Agent keeps memory files, a session database, and a growing directory of skills it wrote itself. Run it on a laptop and that corpus gets interrupted every time you close the lid, travel, or reinstall. Run it on a server and it becomes a thing you message at 7am from a train.

That is the actual argument for self-hosted Hermes Agent on a small server, and it is not about saving money on inference — you pay for tokens either way. It is about continuity and about the gateway. The messaging gateway holds long-lived connections to Telegram, Discord, Slack and the rest; it needs a stable IP, an uptime measured in weeks, and a process supervisor. A desktop gives you none of those.

Netcup fits this shape well. It runs its own hardware in data centers in Nuremberg, Vienna and Amsterdam, with Manassas and Singapore available at a surcharge, puts SSD storage on every VPS tier and NVMe on the Root Server line, and charges €6.94 to €22.62/month excl. VAT across the sizes that matter here. For a workload that idles on a WebSocket most of the day and then spikes a headless Chromium for ninety seconds, that is exactly the right purchase. There is one honest caveat up front: Netcup does not sell GPU servers, so if your plan was local LLM inference, this article is not that. Hermes calls a remote model API; the box runs the agent loop, the tools, and the browser.

By the end you will have Hermes installed under a dedicated service user on a hardened Debian VPS, its terminal tool confined to a Docker sandbox, a Telegram bot that only answers you, the gateway running under systemd, the admin dashboard behind Caddy with TLS, and a backup of the one directory that is not reproducible.

What is Hermes Agent?

Hermes Agent is an open-source, autonomous AI agent built by Nous Research that runs on your own machine, keeps persistent memory across sessions, writes reusable skills from its own experience, and can be reached from a terminal, a desktop app, or more than twenty messaging platforms. It is written in Python and published under the MIT license — genuinely permissive, no source-available asterisk, no commercial-use clause.

It is not a coding copilot bolted into an IDE, and not a chat wrapper around one API. The distinguishing feature is the loop: during and after a task, the agent reviews what happened, extracts the parts worth keeping, and writes them back as memory entries or as skills. The next time a similar task arrives, the skill is already there. That makes it the rare open source AI agent whose behaviour on day sixty differs from day one.

Architecture

The core is a Python package — current first-party installs run on Python 3.14 — plus a managed toolchain the installer provisions itself: pinned Node.js, npm, ripgrep, FFmpeg, and a full Chromium build for browser automation. On a POSIX source install, code lands in ~/.hermes/hermes-agent/, the launcher in ~/.local/bin/hermes, and all mutable state under ~/.hermes/ (overridable with HERMES_HOME).

State is a SQLite database, state.db, opened in WAL mode, holding sessions with FTS5 full-text indexing for cross-session recall. Memory lives as two plain markdown files in ~/.hermes/memories/. Skills are markdown files in skills/, following the agentskills.io format, which makes them portable between agents. Config is a single config.yaml, secrets go in ~/.hermes/.env.

Two network surfaces matter on a server. The gateway exposes an API on port 8642, and the admin dashboard — off unless you enable it — serves on 9119. Neither needs to face the internet for messaging to work: the platform adapters open outbound connections, so a box with no inbound ports open beyond SSH still gets you a working Telegram bot.

An official Docker image, nousresearch/hermes-agent, exists as an alternative to the source install. It is built on Debian 13.4 with Python 3.14, Node.js 26, Chromium and FFmpeg baked in, supervised by s6-overlay, with all state on a volume mounted at /opt/data.

Where it came from

The project has public roots in the OpenClaw / Clawdbot lineage and ships a documented one-command migration path from it, alongside importers that pull an existing Claude Code or Codex CLI setup — instructions, allowlists, MCP servers, skills and memories — into Hermes with hermes import. Releases are frequent; the versioning is calendar-based, with v2026.9.24 current at the time of writing.

How to use Hermes Agent

Core concepts

Five nouns cover most of it:

• Session — one conversation, persisted in state.db. hermes --continue resumes the last one; older sessions stay searchable.
• Memory — two files. MEMORY.md holds the agent's own notes about your environment and conventions; USER.md holds its model of you. Both are injected into the system prompt at session start.
• Skill — procedural memory. A markdown file describing a capability, when to use it, and its limits. The agent writes these itself and improves them in place; the Skills Hub distributes community ones.
• Terminal backend — where shell commands actually execute. local runs on the host; docker runs them in a disposable hardened container. This is the single most consequential setting on a server.
• Gateway — the long-running process that holds platform connections, routes messages to sessions, and enforces user authorization.

Day-to-day workflow

You talk to it. From the CLI it is a TUI with slash commands — /help, /model, /tools, /cron, /yolo — and from Telegram it is a chat. Both hit the same memory and skills, so a task started at a desk continues from a phone.

The part that justifies a server is cron. Hermes has a built-in scheduler with delivery to any connected platform, configured in natural language: a 7am briefing, a nightly backup verification, a weekly digest of a repository's issues. Those jobs run whether or not anyone is watching, which is the whole point of not hosting this on a laptop.

Integrations and extensibility

MCP is first-class: attach any Model Context Protocol server and filter exactly which of its tools Hermes loads, which matters when a server exposes forty tools and you want three. Beyond that there are 60+ built-in tools, an OpenAI-compatible API server so any frontend can drive the agent, webhooks, voice mode, and subagents that run isolated workstreams in parallel. A Nous Portal subscription bundles model access and the hosted Tool Gateway — web search, image generation, TTS, cloud browser — behind one OAuth, which is a reasonable shortcut if you would rather not collect six API keys.

Backup and operational reality

One directory matters: ~/.hermes/. Inside it, memories/, skills/, state.db and config.yaml are the irreplaceable parts — everything else, including the Python environment and Chromium, rebuilds from the installer in minutes. The .env holds credentials, so treat the backup as secret material.

Two operational rules from the docs are worth internalising. Never point two agent processes at the same Hermes home: memory writes are automatic, and two writers will compound each other's entries into state neither authored. And never run two gateways against the same data directory — session files are not built for concurrent writes. If you want a second agent, give it its own profile.

Quick Start Guide

Tested flow on a fresh Debian 13 VPS. Budget twenty minutes, most of it the installer pulling Chromium.

1. Provision the box

Sign up for the VPS 1000 G12.5 at netcup.com using coupon 6877nc17911959133 for one free month. Pick a Debian image, add your SSH public key at creation, then lock it down:

# /etc/ssh/sshd_config.d/00-hardening.conf
PasswordAuthentication no
PermitRootLogin prohibit-password

systemctl restart ssh
apt update && apt -y upgrade
apt install -y git curl ca-certificates libatomic1

libatomic1 is not optional window dressing. The Node.js runtime that Hermes manages links libatomic.so.1, and minimal Debian images do not ship it — the installer will try to fetch it via sudo, which a non-privileged service user cannot do.

2. Install Hermes Agent as a service user

Do not run the agent as root. Create a user, install as that user, and give it the launcher on PATH:

adduser --disabled-password --gecos "" hermes
usermod -aG docker hermes            # after step 3, so it can drive the sandbox
su - hermes
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
export PATH="$HOME/.local/bin:$PATH"
hermes doctor

The installer clones the source, bootstraps uv, and has the project's package manager provision pinned Python, Node, ripgrep, FFmpeg and Chromium. Pass --skip-browser if you know you will never use browser tools — it saves a large download and a lot of RAM later. hermes doctor is the authoritative answer to "did that work"; run it before anything else.

Then point it at a model. One command covers it if you have a Nous Portal subscription:

hermes setup --portal

Otherwise hermes model walks you through a provider, or set a key directly with hermes config set OPENROUTER_API_KEY your_key.

3. Move the terminal into a Docker sandbox

On a server, the agent's shell tool should not run on the host. The Docker backend makes the container the security boundary, which the project's own security docs recommend for production gateways:

curl -fsSL https://get.docker.com | sh

# ~/.hermes/config.yaml
terminal:
  backend: docker
  docker_image: "nousresearch/hermes-sandbox:desktop"
  docker_forward_env: []      # explicit allowlist only — keeps secrets out of the container
  container_cpu: 1
  container_memory: 2048      # MB; default is 5120
  container_persistent: true

Hermes starts those containers with --cap-drop ALL, no-new-privileges, a 256-process limit and size-limited tmpfs mounts. The defaults assume a bigger machine than a VPS 1000 G12.5 — 5 GB of memory and 50 GB of disk per sandbox — so trim container_memory and container_disk to something your tier can actually honour.

4. Connect Telegram and set the allowlist

hermes gateway setup

The wizard asks for a bot token from BotFather and writes it to ~/.hermes/.env. Add your own numeric user ID in the same file:

# ~/.hermes/.env
TELEGRAM_BOT_TOKEN=123456:ABC...
TELEGRAM_ALLOWED_USERS=123456789

Resist GATEWAY_ALLOW_ALL_USERS=true. This agent has a shell.

5. Run the gateway as a service

hermes gateway install
hermes gateway start
hermes status

That generates and enables a systemd user unit. A user unit dies when the user logs out, which on a headless box means it dies when your SSH session ends — so enable lingering once, as root:

loginctl enable-linger hermes

Check it survives a reboot before you trust it. Logs land under ~/.hermes/logs/gateways/default/.

6. Put the dashboard behind Caddy

The dashboard is a full admin panel — config, API keys, MCP servers, sessions, logs, cron jobs, a terminal over WebSocket. Bind it to loopback and let Caddy terminate TLS:

apt install -y caddy

# /etc/caddy/Caddyfile
hermes.example.com {
    reverse_proxy 127.0.0.1:9119
}

# ~/.hermes/.env — required for any non-loopback access path
HERMES_DASHBOARD_BASIC_AUTH_USERNAME=admin
HERMES_DASHBOARD_BASIC_AUTH_PASSWORD=choose-a-strong-password
HERMES_DASHBOARD_BASIC_AUTH_SECRET=$(openssl rand -base64 32)

Caddy fetches a Let's Encrypt certificate the first time it sees an HTTPS request — no certbot, no cron, no expiry surprises. Start the dashboard with hermes dashboard --host 127.0.0.1 --port 9119 --no-open. Note that the dashboard fails closed on a non-loopback bind with no auth provider configured, which is the correct behaviour and will confuse you for five minutes if you skip the env vars.

7. Back up what matters

# from your workstation
rsync -az --exclude 'hermes-agent/' hermes@your-server:~/.hermes/ ./hermes-backup/

The exclusion drops the source checkout, which is reproducible. What is left — memories/, skills/, state.db, config.yaml, .env — is the agent you have actually been training. Hermes also ships hermes backup and hermes export for a portable archive; use those if you plan to move hosts, and keep the rsync copy for the day a disk disagrees with you.

Choosing the Right Netcup Server for cheap Hermes Agent hosting

Sizing Hermes is a question about two things: Chromium, and how many sandboxes you intend to run. The agent loop itself is cheap — it spends most of its life waiting on a model API. The project's own guidance puts the container at 1 GB minimum and 2–4 GB recommended, 1 core minimum and 2 recommended, with browser automation named as the memory-hungry part. Add a Docker sandbox at its default 5 GB ceiling and the comfortable number lands around 8 GB.

Disk is less obvious than it looks. The data volume needs only 500 MB to start and grows into single-digit gigabytes with sessions and skills, but the image or the installed toolchain carries a full Chromium, Node.js and Python runtime, and the sandbox's overlay disk defaults to 50 GB.

VPS 500 G12.5 — the thrifty single-user agent

Specs: 2 vCore, 4 GB ECC RAM, 64 GB SSD, 2.5 Gbit/s, traffic included. Around €7/month excl. VAT (verify on netcup.com).

Why it works for Hermes Agent: one user, one profile, a Telegram bot and a couple of cron jobs fit into 4 GB without drama — provided you either skip browser tools at install time or accept that a Chromium session is most of your headroom. Run the terminal backend locally or cap the Docker sandbox at 1.5 GB. It is a real deployment, not a toy, but it has no room for a second profile and 64 GB is tight once a sandbox overlay starts growing.

Coupons (each pops a different code at build time — €5 off any order, since this tier has no dedicated voucher):

• 36nc17718015540
• 36nc17718015545
• 36nc17718015549

VPS 1000 G12.5 — recommended for most Hermes Agent deployments

Specs: 4 vCore, 8 GB ECC RAM, 128 GB SSD, 2.5 Gbit/s, traffic included. Around €12/month excl. VAT (verify on netcup.com).

Why it works for Hermes Agent: 8 GB is the number where the gateway, a headless Chromium, a Docker sandbox at 2–4 GB and the dashboard coexist without touching swap. Four vCores absorb the page-render and execute_code spikes. 128 GB SSD leaves the sandbox overlay room to grow without you auditing disk usage monthly. This is the tier where the agent stops being a resource-management exercise.

Coupons (each pops a different code at build time):

• 6877nc17913304870
• 6877nc17911959135
• 6877nc17911959132

VPS 2000 G12.5 — multiple profiles, bots, and parallel subagents

Specs: 8 vCore, 16 GB ECC RAM, 256 GB SSD, 2.5 Gbit/s, traffic included. Around €23/month excl. VAT (verify on netcup.com).

Why it works for Hermes Agent: Bot Mode and multi-profile deployments multiply the footprint — each profile is a supervised gateway with its own memory, skills and sessions, and each one that browses wants its own Chromium. 16 GB also lets you leave the sandbox defaults alone instead of trimming them, and run the agent cache without it shedding transcripts under memory pressure. This is the shape of a small team's shared agent, or one agent that genuinely parallelises subagents.

Coupons (each pops a different code at build time):

• 6878nc17911959160
• 6878nc17911959164
• 6878nc17911959162

RS 1000 G12.5 — dedicated cores for browser work and code execution

Specs: 4 dedicated cores (AMD EPYC 9645), 8 GB ECC RAM, 128 GB NVMe. Around €18/month excl. VAT (verify on netcup.com).

Why it works for Hermes Agent: VPS vCores are shared and oversubscribed, which is fine for a process that waits on an API — and less fine for the ten seconds when Chromium renders a page or a Python kernel chews through a dataset. Dedicated Zen 5 cores make those bursts consistent instead of occasionally terrible, and NVMe helps the SQLite session store under concurrent gateway, cron and worker writes. For about 6 € over the VPS 1000 G12.5 it is the pick when the agent runs real work on a schedule, and its coupon is worth two free months rather than one.

Coupons (each pops a different code at build time — two free months on this tier):

• 6874nc17911959062
• 6874nc17911959061
• 6874nc17911959064

Which one should you pick? If you are trying Hermes Agent for the first time and it is just you and a Telegram bot, the VPS 500 G12.5 does the job for the price of a sandwich — install with --skip-browser and you will not notice the ceiling. If you intend to actually live with this thing, take the VPS 1000 G12.5: browser tools on, Docker sandbox on, dashboard on, no tuning required. If you are running Bot Mode for a team, several profiles, or subagents in parallel, go VPS 2000 G12.5 for the RAM, or RS 1000 G12.5 if your jobs are CPU-bursty and you care more about predictable latency than about headroom.

Conclusion

You now have a path from an empty Debian VPS to an agent that runs as a supervised service, executes its shell commands inside a hardened container, answers only you on Telegram, serves its dashboard over TLS, and keeps a backup of the memory and skills it has accumulated.

The bill is modest and entirely separate from your model spend. The recommended VPS 1000 G12.5 is €12.18/month excl. VAT, and the coupons above make the first month free — call it 134 € for the first year of an always-on agent. If you end up on a different product entirely, the €5-off-any-order code 36nc17718015548 applies storewide.

Three things deserve attention once it is running. Watch memory: the gateway caches a full agent per session, transcripts included, and that cache is the largest single consumer of RAM on a busy multi-platform box — the agent.agent_cache settings exist precisely because it will grow into whatever you give it. Watch your approval policy: approvals.mode and the approvals.deny glob list are the difference between an agent that asks before rm -rf and one that does not, and a container boundary is worth more than either. And verify a restore at least once, because an agent's accumulated memory is the one part of this setup that no reinstall brings back. More self-hosting guides live on the blog.