Agenhood vs Hermes Agent

Hermes Agent suits people who want one personal agent that learns from its own work, remembers them across sessions and answers from Telegram, Slack or the terminal. Agenhood suits teams that want many agents on one server, each sandboxed in its own container, created and tasked through a REST API.

Last updated

If you are looking for a Hermes Agent alternative, first decide whether you want one agent or many. Hermes Agent, built by Nous Research, is an open-source personal agent with a learning loop: it keeps a memory of you, writes skills from its own work and gets better at the tasks you give it. Agenhood is a platform for running many agents on a server, each in its own sandboxed container, for a team that sends them work from an API, a schedule or a shared console. Both are MIT licensed and self-hosted.

The short answer

Pick Hermes Agent if

  • You want one personal agent that remembers you and improves its own skills.
  • You want to reach it from Telegram, WhatsApp, Signal, Slack or the terminal.
  • You like its skill system and its community.
  • You want local or self-hosted models.

Pick Agenhood if

  • You need many agents, each isolated in its own container by default.
  • You need team workspaces with roles, shared by several people.
  • You want a REST API that creates, tasks and rolls back agents.

Side by side

Topic Hermes Agent Agenhood
Main use One self-improving personal agent, used from a terminal UI, a desktop app or chat apps. Runs on a laptop, a VPS or serverless backends. source A fleet of long-lived agents on one Linux server, tasked from a console, the API, schedules, GitHub or Slack.
Isolation default The terminal backend is local by default: commands run where Hermes runs, with an approval step for risky ones. With Hermes's Docker image, that is inside the Hermes container. sourcesource Always on. One hardened container per agent: read-only root filesystem, dropped capabilities, CPU and memory caps.
Sandbox options Seven backends: local, Docker, SSH, Singularity, Modal, Daytona and Vercel Sandbox. The Docker backend is one persistent container per Hermes process. source Docker only, one container per agent, on a single host.
Network Web tools block private and cloud metadata addresses by default. A guide shows how to add an egress proxy when Hermes runs in Docker. sourcesource Agents sit on an internal network with no gateway. A filtering egress proxy is the only way out and blocks private ranges and metadata endpoints.
Several agents Profiles: separate Hermes homes on one machine, each with its own config, keys, memory, skills and cron jobs. Subagents split one job into parallel workstreams. sourcesource Each agent has its own container and /workspace volume. Idle agents pause and wake on the next task.
Memory and skills Agent-curated memory, skills it writes after complex tasks and improves during use, and search across past sessions. source Files persist in the workspace and tasks can continue a session. Skills come from Git repos you attach.
Rollback Opt-in checkpoints in a shadow Git repo, taken before file edits and destructive commands. Restore with /rollback. source Without a linked Git repo, a workspace snapshot after every task, with non-destructive rollback from the console.
API An OpenAI-compatible API server with runs and event streams, off until you enable it. source REST API plus server-sent events for everything the console does, including creating agents. Named, revocable API keys.
Scheduling Built-in cron in plain language or cron expressions, with delivery to chat platforms. Jobs can also fire from webhooks. source One-time or recurring presets in your timezone, with a calendar of upcoming runs. A schedule can start a workflow.
Admin and teams A web dashboard manages every profile on a machine. On a network address it requires a password or Nous Portal login. source Multi-tenant workspaces with owner, admin and member roles. Admins create accounts.
Models Many providers, from hosted APIs to self-hosted endpoints such as Ollama and vLLM. source Anthropic and OpenAI models, plus Opencode's own model plans, through five drivers chosen per agent.
License and price MIT. Free, with an optional Nous Portal subscription for models and tools. source MIT. Free. You pay for your server and for model usage on your own keys.

One agent that learns, or many agents you send work to

Hermes Agent is built around one relationship. Its README describes agent-curated memory, skills it creates after complex tasks and improves while using them, and search across past conversations. You talk to it from the terminal, the desktop app or a gateway that connects Telegram, Discord, Slack, WhatsApp, Signal and more. If you want more than one, profiles give each agent its own home directory with separate config, keys, memory and skills.

Agenhood is built around tasks. An agent is a container with a driver, a model, tools and a /workspace volume. You create it with one API call, send it work, and watch messages, tool calls and file changes stream into the console. It doesn't learn on its own, but its files stay put, so a nightly agent can read what it wrote last night.

Terminal
# One agent per job, each in its own container with its own limits
curl -X POST http://localhost:5173/v1/containers \
  -H "Authorization: Bearer tk_live_seedkey" \
  -H "Content-Type: application/json" \
  -d '{"name": "support-triage", "config": {"driver": "vanilla", "model": "claude-sonnet-4-6", "tools": ["web_search", "web_fetch", "read_file", "write_file"]}, "resource_limits": {"mem_limit": "2g", "cpus": 1}}'

curl -X POST http://localhost:5173/v1/containers \
  -H "Authorization: Bearer tk_live_seedkey" \
  -H "Content-Type: application/json" \
  -d '{"name": "release-notes", "config": {"driver": "codex", "model": "gpt-5.5"}}'

# Hand one of them a task (agents are "containers" in the API)
curl -X POST http://localhost:5173/v1/containers/$AGENT_ID/tasks \
  -H "Authorization: Bearer tk_live_seedkey" \
  -H "Content-Type: application/json" \
  -d '{"prompt": "Summarize the latest release notes and save them to notes.md"}'

Use the id from a create response as $AGENT_ID. Each agent gets its own container, workspace and resource caps, and a teammate in the same workspace can see and task it.

Isolation: a backend you choose, or a container per agent

Hermes Agent gives you a lot of choice. Its terminal backends are local, Docker, SSH, Singularity, Modal, Daytona and Vercel Sandbox, and the default is local, so commands run on your machine. Its security guide recommends a container or cloud backend for production gateways. The Docker backend drops all Linux capabilities except three that package managers need, sets no-new-privileges and a process limit, and runs one persistent container for the whole Hermes process. When Hermes itself runs in Docker, the default host networking gives it open outbound access, and an egress guide shows how to put it behind an allowlisting proxy.

Agenhood has one setup and no switch to forget. Every agent is its own Docker container with a read-only root filesystem, dropped capabilities and CPU and memory caps. Agents sit on an internal network with no gateway, and a filtering egress proxy lets them reach the internet and model APIs while blocking private IP ranges and cloud metadata endpoints.

Internal network, no gateway Agent container driver process /workspace volume Egress proxy filters every request Internet LLM APIs, web allowed Blocked: 10/8, 172.16/12, 192.168/16, loopback, 169.254/16 (cloud metadata)

APIs, dashboards and teams

Hermes Agent's API server is OpenAI-compatible, so chat frontends such as Open WebUI can use the agent as a backend, and a runs endpoint streams progress. You turn it on with an environment variable. Its web dashboard manages config, keys, sessions, cron jobs and skills for every profile on the machine.

Agenhood's REST API covers the whole platform: creating agents, tasks, schedules, workflows, files, snapshots and credentials. Every resource belongs to a workspace, a person can belong to several, and each workspace has owner, admin and member roles. That is the main reason to pick Agenhood over Hermes Agent for a team: separate agents and permissions, not one shared assistant.

Undoing a bad run

Hermes Agent's checkpoints are opt-in. When on, they snapshot a project into a shadow Git repo before file edits and destructive commands, and /rollback restores all of it or one file. Agenhood snapshots an agent's whole workspace after every task, unless the agent is linked to a Git repo. Rolling back adds a new snapshot with the old files, so you can change your mind again.

What Hermes Agent does better

  • An agent that improves itself. Memory, skills it writes and refines, and cross-session search are built in. Agenhood has nothing like it.
  • Chat apps everywhere. Telegram, Discord, Slack, WhatsApp, Signal, email and more through one gateway. Agenhood only connects to Slack and GitHub.
  • Runs almost anywhere. Installers for Linux, macOS, Windows and Android, a desktop app, and serverless backends that sleep when idle. Agenhood runs on one Docker host: make dev on your own machine, or make prod on a VM.
  • More model choice. Hosted providers and self-hosted endpoints like Ollama and vLLM. Agenhood is limited to Anthropic and OpenAI models and Opencode plans.

Moving over, or using both

The two fit together well. Keep Hermes Agent as your personal assistant and move the work that needs its own sandbox, runs for a team or is started from code to Agenhood. Run make dev, add an Anthropic or OpenAI key under Settings, Credentials, and create one agent per job. If a skill you rely on lives in a Git repo, add it to Agenhood from that repo and attach it to the agent. Recreate Hermes cron jobs as Agenhood schedules, and copy any notes the agent needs into its workspace.

What it doesn't do

  • No learning loop. Agents don't build a memory of you or write their own skills. For a personal agent that grows with you, use Hermes Agent.
  • It is a hardened container, not a VM. Agents share the host's kernel. For a stronger boundary, give Agenhood its own VM.
  • One Docker host, and you run it. No Kubernetes, no serverless backends and no hosted version, so updates and backups are on you.

Questions people ask

Is Hermes Agent sandboxed by default?

Not by default. Its terminal tool runs on your machine unless you pick another backend, and an approval step checks risky commands first. Hermes Agent's docs recommend the Docker, Modal, Daytona or Vercel Sandbox backend for production gateways, and its Docker backend drops almost all Linux capabilities and limits processes.

Does Agenhood learn from past tasks like Hermes Agent?

Not in the same way. Agenhood doesn't curate a memory or write its own skills. An agent keeps the files in its workspace, so it can keep notes there, a task can continue an earlier session, and you can attach skills from Git repos. If an agent that improves itself is what you want, Hermes Agent is the better fit.

Can I run Hermes Agent inside Agenhood?

No. Agenhood runs its own five drivers: Vanilla, Opencode, Codex, Claude Code and a single-call API driver. Hermes Agent is not one of them. You can run both on the same server as separate tools.

Can Agenhood use local models?

No. Agenhood supports Anthropic and OpenAI models, plus Opencode's own model plans through the Opencode driver. Hermes Agent works with many providers, including self-hosted endpoints such as Ollama and vLLM.

Which one is better for a team?

For a shared assistant in one chat, Hermes Agent works well. For a team that needs separate agents per person or per job, each in its own container, with workspaces, roles and an API to create agents from code, Agenhood is built for that. Both are self-hosted, so you run and secure the server either way.

What does each one cost?

Both are free and MIT licensed. Hermes Agent offers an optional Nous Portal subscription for models and tools. Agenhood has no paid tier. With either one, you pay for the machine and for model usage on your own keys or plans.

Run it locally in one command

You need Docker and Python 3.12 or newer. make dev builds the agent image, starts the stack, runs migrations, creates a login and prints the console URL.

Terminal
git clone https://github.com/appssemble/agenhood.git
cd agenhood
make dev

Sources

  1. Hermes Agent README
  2. Hermes Agent license
  3. Installation
  4. Tools and terminal backends
  5. Security
  6. Hermes Docker setup
  7. Network egress isolation (Docker)
  8. Profiles: running multiple agents
  9. Checkpoints and /rollback
  10. API server
  11. Web dashboard
  12. Scheduled tasks (cron)
  13. Inference providers