How do I change the Hermes Agent terminal backend?

Run hermes config set terminal.backend docker, swapping docker for local, ssh, modal, daytona, vercel_sandbox or singularity. The setting is saved under terminal.backend in ~/.hermes/config.yaml. You can check the current value with hermes config get terminal.backend.

Which Hermes Agent backend is the default?

The default terminal backend is local, which runs commands directly on your machine with no isolation. The docs call it the safest default when you are getting started, because it needs no extra setup.

Is the Docker backend safer than the local backend?

Yes. The local backend gives the agent the same file access as your user account. The Docker backend runs commands inside a container with all Linux capabilities dropped, no privilege escalation and a limit of 256 processes, so a bad command is contained.

Hermes Agent Backend: How To Switch Local, Docker Or SSH

Q: What is a Hermes Agent backend?

In Hermes Agent, backend usually means the terminal backend, which decides where the agent's shell commands run. The docs list seven: local, docker, ssh, modal, daytona, vercel_sandbox and singularity. The word is also used for the model provider, the web search provider, the browser provider and the memory provider.

Q: Can I use Hermes Agent as a backend for another app?

Yes. The API server exposes Hermes as an OpenAI-compatible endpoint on port 8642 for frontends such as Open WebUI. Hermes can also run as an ACP server for editors with hermes acp, and as an MCP server for other agents with hermes mcp serve.

A Hermes Agent backend is the part of your setup that does the real work behind the chat window, and the word covers six different things in Hermes.

The most common meaning is the terminal backend, which decides where the agent's shell commands actually run.

The official docs list seven terminal backends, and they are local, Docker, SSH, Modal, Daytona, Vercel Sandbox and Singularity.

"Backend" also means the model provider that does the thinking, the web search provider, the browser provider, the memory provider, and Hermes itself running as a backend for another app.

This post walks through every one of them as an operator would, with the real commands and config keys.

Every fact below comes from the official Hermes docs and the read-only --help output on my own install, which is version 0.21.4.

What "Backend" Means In Hermes Agent

Hermes Agent is the free, open-source AI agent from Nous Research, and it is released under the MIT licence.

The docs use the word "backend" for several different layers, so I've put them all in one table.

Backend type	What it controls	Documented options	How you set it
Terminal backend	It controls where shell commands run.	The options are local, docker, ssh, modal, daytona, vercel_sandbox and singularity.	You run `hermes config set terminal.backend <name>`.
Model backend	It controls which model does the thinking.	The options include Nous Portal, OpenRouter, Anthropic, OpenAI, Bedrock, Ollama, LM Studio and any custom endpoint.	You run `hermes model`.
Web backend	It controls search and page extraction.	The options include Firecrawl, SearXNG, Brave, DuckDuckGo, Exa, Parallel, Tavily and Perplexity.	You run `hermes tools` or set `web.backend`.
Browser backend	It controls which browser the agent drives.	The options include Browser Use, Browserbase, Firecrawl, Camofox, Lightpanda and local Chromium.	You run `hermes tools` and pick Browser Automation.
Memory backend	It controls long-term memory beyond the built-in files.	The options include Honcho, OpenViking, Mem0, Holographic, RetainDB, ByteRover and Supermemory.	You run `hermes memory setup`.
Hermes as a backend	It lets other apps use your agent.	The options are the API server, ACP, MCP serve and the headless `hermes serve`.	You run the matching command for each one.

The rest of this post goes through that table one row at a time.

The Seven Hermes Agent Backend Options For The Terminal

The terminal backend is the one most people mean when they search for a Hermes Agent backend.

The docs describe it this way: each backend determines where the agent's shell commands actually execute.

Backend	Where commands run	Isolation	The docs say it's best for
`local`	They run on your machine directly.	There is none.	It's best for development and personal use.
`docker`	They run in one persistent Docker container.	It is full, with namespaces and dropped capabilities.	It's best for safe sandboxing and CI/CD.
`ssh`	They run on a remote server over SSH.	It is a network boundary.	It's best for remote dev and powerful hardware.
`modal`	They run in a Modal cloud sandbox.	It is full, in a cloud VM.	It's best for ephemeral cloud compute and evals.
`daytona`	They run in a Daytona workspace.	It is full, in a cloud container.	It's best for managed cloud dev environments.
`vercel_sandbox`	They run in a Vercel Sandbox microVM.	It is full, in a cloud microVM.	It's best for cloud execution with snapshot-backed persistence.
`singularity`	They run in a Singularity or Apptainer container.	It uses namespaces with `--containall`.	It's best for HPC clusters and shared machines.

My own config has terminal.backend set to local, which is the default.

🔥 Want my exact Hermes Agent Backend setup, step by step? Inside the AI Profit Boardroom you get step-by-step video trainings, my installable Agent OS and four coaching calls a week with 3,400+ members building real automations. → Join the AI Profit Boardroom

How To Switch Your Hermes Agent Backend

You switch the terminal backend with one command.

hermes config get terminal.backend
hermes config set terminal.backend docker

The first line prints what you're on now, and the second line changes it.

The value is saved in ~/.hermes/config.yaml under the terminal: block, so you can edit the file by hand if you prefer.

terminal:
  backend: local    # local | docker | ssh | modal | daytona | vercel_sandbox | singularity
  timeout: 180      # Per-command timeout in seconds

The docs also say every key under terminal: has an environment override of the form TERMINAL_<KEY>.

If a new backend fails, you set the value back to local and run hermes doctor to see what's missing.

Setting Up Each Terminal Backend

Local

The local backend needs no setup at all.

Commands run with your real home folder, so tools like git, gh and npm find the logins they already use.

The docs carry a plain warning here, which is that the agent has the same filesystem access as your user account.

Docker

You need Docker Desktop or Docker Engine installed and running, and you can check it with docker version.

terminal:
  backend: docker
  docker_image: "nikolaik/python-nodejs:python3.11-nodejs20"
  docker_mount_cwd_to_workspace: false
  docker_network: true
  container_cpu: 1
  container_memory: 5120
  container_persistent: true

Hermes starts one long-lived container on first use and sends every terminal, file and code call into it with docker exec.

That means a package you install once is still there on the next command, and it's still there after you restart Hermes.

Setting container_persistent: false gives every chat its own fresh container that is removed when the session ends.

Setting docker_network: false runs the container with no network at all.

Podman works too, and the docs say you set HERMES_DOCKER_BINARY=podman to force it.

SSH

The SSH backend needs two values in ~/.hermes/.env.

TERMINAL_SSH_HOST=my-server.example.com
TERMINAL_SSH_USER=ubuntu

TERMINAL_SSH_PORT and TERMINAL_SSH_KEY are optional.

Hermes keeps one shell alive on the remote host, so your working directory and environment variables survive between commands.

The tools page recommends SSH for security, because the agent can't modify its own code when it works on a different machine.

If you want a server to point it at, I've ranked hosts in the best Hermes Agent VPS.

Modal, Daytona And Vercel Sandbox

These three are cloud sandboxes, and each one needs its own account and credentials.

Modal needs MODAL_TOKEN_ID and MODAL_TOKEN_SECRET, or a ~/.modal.toml file.
Daytona needs DAYTONA_API_KEY, and the docs note a 10 GiB disk limit.
Vercel Sandbox needs VERCEL_TOKEN, VERCEL_PROJECT_ID and VERCEL_TEAM_ID, and it supports the node24, node22 and python3.13 runtimes.

With container_persistent: true, all three keep your files between sessions.

The docs are clear that this saves the filesystem only, so running processes and background jobs don't come back.

Singularity

The Singularity backend needs the apptainer or singularity binary on your path.

It exists for HPC clusters and shared machines where Docker isn't allowed.

Docker image addresses are converted to SIF files and cached for you.

🔥 Want to see how I wire Hermes up in my own business? Inside the AI Profit Boardroom, I share my Hermes setups on video, and you can ask me questions on four coaching calls a week alongside 3,400+ members. → Get access here

The Model Backend: Which Provider Does The Thinking

The second meaning of a Hermes Agent backend is the model provider.

You manage it with two commands, and they do different jobs.

Command	Where you run it	What it does
`hermes model`	You run it in your terminal, outside a chat.	It is the full wizard that adds providers, runs logins and saves keys.
`/model`	You type it inside a chat.	It switches between providers you've already set up.

Here are the main provider backends and how each is set.

Provider backend	How you set it
Nous Portal	You run `hermes setup --portal` on a new install, or pick it in `hermes model`.
OpenRouter	You add `OPENROUTER_API_KEY` to `~/.hermes/.env`.
Anthropic	You pick it in `hermes model`, with a login or an API key.
OpenAI API	You add `OPENAI_API_KEY`, and the provider name is `openai-api`.
AWS Bedrock	You pick "AWS Bedrock" in `hermes model`, and it uses your standard AWS credentials.
Ollama	You pick "Custom endpoint" and enter `http://localhost:11434/v1`.
LM Studio	You pick "LM Studio" in `hermes model`, and its server starts on port 1234.
Custom endpoint	You set `provider: custom` and a `base_url` for any OpenAI-compatible server.

The docs call Nous Portal the recommended way to run Hermes, because one login covers 300+ models plus the Tool Gateway.

The docs warn that Ollama uses a low context length by default, so you set context_length in the config when you run a local model.

Bedrock has enough moving parts that I gave it its own walkthrough in Hermes Agent on Bedrock.

🚀 Ready to put Hermes Agent Backend to work in your business? Inside the AI Profit Boardroom you get step-by-step video trainings, my installable Agent OS and four coaching calls a week with 3,400+ members building real automations. → Join the AI Profit Boardroom

The Web, Browser And Memory Backends

Web Search Backends

Hermes has two web tools, web_search and web_extract, and one backend choice sits behind both.

Firecrawl is the default, and the other documented providers are SearXNG, Brave Search, DuckDuckGo, Exa, Parallel, Tavily, Perplexity, Keenable, xAI and OpenAI Native.

A fresh install works with no key, because requests rotate across the free tiers of Exa, Parallel, Firecrawl and Keenable.

web:
  search_backend: "searxng"
  extract_backend: "firecrawl"

That split lets you pair a free search provider with a different extract provider.

Browser Backends

The browser toolset has its own list, which covers Browser Use, Browserbase, Firecrawl, Camofox, Lightpanda, your own Chrome over CDP and a local Chromium.

You choose one by running hermes tools and opening Browser Automation, which writes browser.cloud_provider to your config.

I cover the whole toolset in the Hermes Agent browser guide.

Memory Backends

The built-in memory files, MEMORY.md and USER.md, are always on.

You can add one external memory provider on top with hermes memory setup, and only one can be active at a time.

The docs name Honcho, OpenViking, Mem0, Holographic, RetainDB, ByteRover and Supermemory, and Hindsight installs from the plugin catalog.

My ranking of them is in the best Hermes Agent memory.

Using Hermes Agent As A Backend For Other Apps

The last meaning flips the direction, because Hermes itself becomes the backend.

Mode	Command or setting	What connects to it
API server	You set `API_SERVER_ENABLED=true` and `API_SERVER_KEY` in `~/.hermes/.env`, then run `hermes gateway`.	Any OpenAI-compatible frontend, such as Open WebUI or LobeChat, connects to it.
ACP server	You run `hermes acp`.	Editors such as VS Code, Zed and JetBrains connect to it.
MCP server	You run `hermes mcp serve`.	Other agents, such as Claude Code or Cursor, connect to it.
Backend server	You run `hermes serve`.	The Hermes desktop app and remote clients connect to it.
Subscription proxy	You run `hermes proxy start`.	Apps that only need the raw model connect to it.

The API server listens on http://127.0.0.1:8642 and speaks the OpenAI Chat Completions and Responses formats.

Your agent answers with its full toolset, so a chat frontend gets terminal, files, web search, memory and skills behind it.

hermes mcp serve is stdio-only today, according to the docs.

hermes serve is the headless JSON-RPC and WebSocket server on port 9119, and a public bind always requires an auth provider.

If you want agents that keep working after you close the window, read Hermes Agent background tasks next.

Security Trade-Offs Between Local And Docker

This is the decision that matters most, so I'll be direct.

Backend	Isolation	Dangerous command check
local	It has none, because it runs on the host.	The check is on.
ssh	It runs on a remote machine.	The check is on.
docker	It runs in a container.	The check is skipped, because the container is the boundary.
modal, daytona, vercel_sandbox	They run in a cloud sandbox.	The check is skipped.
singularity	It runs in a container.	The check is skipped.

On local, Hermes checks every command against a list of dangerous patterns and asks you before it runs a match.

On Docker, the container starts with all capabilities dropped, no privilege escalation and a limit of 256 processes.

The docs recommend docker, modal, daytona or vercel_sandbox for production gateway deployments.

There is one catch, which is that anything you list in docker_forward_env can be read by code inside the container.

Performance And Cost

The local backend has nothing between the agent and your shell, so there is no sandbox to start.
The Docker backend reuses one container, so the next Hermes process attaches to it instead of building a new one.
The SSH backend reuses one connection and one shell, so you don't pay a login on every command.
Container backends default to 1 CPU core and 5 GB of memory, and you can raise both in the config.
Every command has a 180 second timeout by default.

The docs also warn that slow shell startup files, such as an nvm line in .bashrc, add delay to every command the agent runs.

On cost, Hermes is free, and local, Docker, SSH and Singularity cost nothing beyond your own hardware or server.

Modal, Daytona and Vercel Sandbox are paid cloud services with their own pricing, so check each one before you commit.

🔥 Ready to run agents that work while you sleep? The AI Profit Boardroom has my Hermes training, my agent setups and four coaching calls a week, so you can copy what works instead of guessing. → Join the AI Profit Boardroom

Common Mistakes With A Hermes Agent Backend

People switch to Docker without Docker running, and the terminal tool then reports as disabled.
People set the SSH backend and forget TERMINAL_SSH_USER, and both values are required.
People expect a cloud sandbox to keep a dev server alive, and only the files are saved.
People try to add a new provider with /model, and that job belongs to hermes model.
People forward every secret into the container, which removes the point of the sandbox.

Also On Our Network

FAQ: Hermes Agent Backend

What is a Hermes Agent backend?

It usually means the terminal backend, which decides where the agent's shell commands run.

The same word is used for the model provider, the web provider, the browser provider and the memory provider.

How do I change the terminal backend?

You run hermes config set terminal.backend docker, and you swap docker for any of the other six names.

You can confirm the change with hermes config get terminal.backend.

Which backend is the default?

The default is local, which runs commands directly on your machine.

Is the Docker backend safer than local?

Yes, because commands run inside a hardened container instead of on your own user account.

Can I use Hermes Agent as a backend for another app?

Yes, and the API server is the usual route, because it gives any OpenAI-compatible frontend a full agent on port 8642.

📺 Video notes + links to the tools 👉

🎥 Learn how I make these videos 👉

🆓 Get a FREE AI Course + Community + 1,000 AI Agents 👉

About Julian

I'm Julian Goldie, an SEO entrepreneur, author and founder of the AI Profit Boardroom, which has 3,400+ members.

I help business owners scale with AI agents, automation and SEO.

I've built a 7-figure SEO and link-building agency, Goldie Agency, with 70+ people in Bangkok.
I've grown a YouTube channel to 400,000+ subscribers.
I wrote the book "Link Building Mastery", which covers nine link building strategies.
My Udemy courses have taught 29,000+ students.

→ Get my best AI training inside the AI Profit Boardroom

Start on local, move to Docker the day your agent takes messages from other people, and you'll have picked the right Hermes Agent backend.