Hermes Agent
Nous Research’s self-improving agent - learns skills from experience, with cron, hooks, and a web dashboard.
One-click deploy, from $13/mo on a Miget plan.
Hermes Agent is Nous Research’s take on agents that get better at your tasks: a learning loop distills successful sessions into reusable skills, so the agent you run in month two is measurably more capable at your workflows than the one you deployed. Plus the practical machinery - cron, hooks, a web dashboard.
This template runs the official image as a single container with a 5 GB /opt/data volume where everything persistent lives: sessions, memories, learned skills, and config. The dashboard sits behind basic auth on your domain; the gateway API stays project-internal unless you opt in.
Like every agent in this catalogue: treat it as a privileged deployment. It runs on your Anthropic API key with a persistent memory - scope the key, cap the spend, and enjoy having an employee who files their own learnings.
Upstream project: Hermes Agent (Nous Research)
#what you get
- Learning loop: successful sessions become reusable skills
- Persistent memories, sessions, and skills on the /opt/data volume
- Cron-style scheduled tasks and event hooks
- Web dashboard behind basic auth
- Optional project-internal gateway API for programmatic access
- Official Nous Research image, single container
#topology
| Service | Role | Public |
|---|---|---|
| hermes | agent + dashboard (:5000); gateway API :8642 internal | yes (basic auth) |
#miget sizing
// this stack needs
2 GiB RAM · 5 GB disk · 1 service
2 GiB suits the agent runtime; model inference happens via API. The 5 GB volume is where the interesting part - accumulated skills and memories - lives, so back it up if the agent becomes load-bearing.
Hobby - recommended fit
$13/mo
1 vCPU · 2 GiB · 50 GiB disk
Headroom for your own apps: 2 GiB at $19/mo
Professional - production
$22/mo
1 vCPU · 2 GiB · 10 GiB disk
Dedicated resources, production SLOs - plan details
One Miget plan is a fixed pool of compute - the whole stack (managed databases included) deploys inside it, and anything left over runs your other apps. No per-service or per-seat math.
#vs. other PaaS
Estimated monthly cost of running this exact stack (2 GiB RAM, 5 GB disk, 1 container) elsewhere, from published June 2026 rates.
| Platform | Est. monthly | Notes |
|---|---|---|
| Miget ★ | $13 flat | compose stacks first-class: one deploy, dedicated vCPU, managed Postgres/Valkey, volumes and TLS all included in the plan |
| Heroku | ~$100 | no volumes; nothing between 1 GB ($50) and 2.5 GB ($250) dynos - 2 GB containers cost far more than shown |
| DO App Platform | ~$29 | no persistent volumes - stateful containers need managed DBs/Spaces (base $5 Spaces included here) |
| Render | ~$26 | per-service instances (0.5 GB $7, 2 GB $25) - every container is its own paid service |
| Railway | ~$21 | usage-based ($10/GB RAM-mo); vCPU billed separately at $20/vCPU-mo on top |
| Fly.io | ~$13 | cheapest sticker price - but burstable shared CPUs (1/16 core; dedicated vCPUs cost ~2-3×), no compose deploys (one app per container, manual wiring), managed DBs billed extra |
Estimates assume RAM fully allocated at published on-demand rates - and sticker price isn't the whole comparison: the cheaper rows buy burstable shared CPUs, per-service wiring instead of a compose deploy, and managed databases billed separately. Heroku and DO App Platform have no persistent volumes at all - stateful stacks like this one need workarounds there.
#deploy it
On Miget
- Create a Compose Stack in app.miget.com pointing at the templates repository
- Set the stack path to
hermes -
Set the required variables:
HERMES_PASSWORD, dashboard basic authHERMES_SESSION_SECRET, session secret (openssl rand -hex 32)ANTHROPIC_API_KEY, the agent’s model access, billed to you
- Deploy. Miget layers
compose.miget.yaml(RAM, privacy, volumes, managed services) automatically
Locally first?
Every template is portable, vanilla Docker Compose - the Miget overrides are ignored locally:
git clone https://github.com/deployable-sh/stacks
cd miget-compose-templates/hermes
docker compose up -dSame files, same behavior. The template README covers connection strings and scaling notes.
#faq
What makes Hermes different from other self-hosted agents?
The learning loop: it reviews its own successful sessions and distills them into skills it applies to future tasks. Most agents start from zero every session; Hermes is designed to compound.
Why is this template marked experimental?
Hermes Agent’s deployment shape is still stabilizing upstream - image layout and config evolve. The template tracks it, but expect occasional breaking updates; pin versions for anything you rely on.
Can other apps call Hermes programmatically?
Yes - enable the gateway API with API_SERVER_ENABLED=true and an API_SERVER_KEY. It listens project-internally on hermes:8642, so other apps in the project can submit tasks without anything public.
What does the agent remember between restarts?
Everything that matters: sessions, memories, learned skills, and configuration persist on the /opt/data volume across redeploys and restarts.
Ship Hermes Agent today
One compose stack, 2 GiB of RAM, from $13/month flat, and it runs on your laptop with the same files.