Hermes Agent system requirements: what you need to run it

The short answer: minimum and comfortable

The table uses the official figures where they exist and says so where they do not. The main RAM and disk numbers Hermes publishes for the agent are in its Docker guide, and the local-model numbers come from its Ollama and Mac guides.

Operating systems: macOS on Apple Silicon, Windows 10 and 11, Linux and WSL2 on x86_64 or aarch64, and Docker on x86_64 or aarch64 are the officially supported platforms. The next sections explain each row and the platforms in more detail.

Supported operating systems

Hermes sorts platforms into tiers. Tier 1 is the set the maintainers say they work hardest not to break:

• macOS on Apple Silicon. The macOS installer supports only Apple Silicon. An Intel Mac can still install the command-line version and run hermes desktop.
• Windows 10 and 11 (x86_64 and aarch64), natively, with no WSL, Docker or Cygwin needed. The packaged desktop app is stricter: it needs Windows 11 22H2 or later.
• Linux and WSL2 on x86_64 or aarch64. Upstream tests on the latest Ubuntu and WSL2, and says a distribution with glibc, systemd and the standard filesystem layout is likely to work well.
• Docker on x86_64 or aarch64. Docker installs do not support hermes update; you update by running a newer image.

Tier 2 is best effort, with no promise of a quick fix when a release breaks it: Nix on macOS, Linux and NixOS, and Android through Termux. Installing from PyPI with pip or uv tool install, installing with Homebrew, and installing from the AUR are listed as unsupported.

What the installer handles, and what it needs from you

You do not install Python or Node.js first. The source installer clones the code, sets up the uv package tool, and hands the rest to Hermes’s own package manager, which provides a pinned Python, Node.js, npm, ripgrep and FFmpeg. In the 0.22.5 lock file that is Python 3.14 and Node.js 26. The project itself declares Python 3.11 up to, but not including, 3.15, but you do not pick the version on an installer-based set-up.

It also installs the browser and computer-use tools by default: agent-browser with its own pinned Chromium, and the computer-use driver on macOS, Windows and glibc Linux. If one of those downloads fails the install still finishes and prints the command to retry. Leave them out with --skip-browser and --skip-computer-use on Linux and macOS, or -SkipBrowser and -SkipComputerUse on Windows.

What you do need to have:

• Git on Linux and macOS. The Linux and macOS script stops with “git is required” if it is missing. On macOS git comes with Apple’s Command Line Tools, and the script walks you through that dialog. The same script also needs curl and tar, which most systems already have.
• Git on Windows is handled for you. The Windows installer looks for Git and, when it is absent, stages a verified copy of Git for Windows.
• A network connection during install, and later for your model provider unless you run a local model.

Install commands, first-run setup and errors are covered in how to install Hermes Agent. The Hermes documentation gives no minimum free disk figure for a source install, so leave generous room for the managed Python, Node.js and Chromium, plus any local models.

What actually drives memory use

For a cloud-model agent the Hermes documentation gives numbers only for Docker: 1 GB of memory as a minimum, 2 to 4 GB recommended, with browser automation called out as the most memory-hungry feature. Without browser tools 1 GB is described as enough, and with them it advises at least 2 GB. These are container figures; there is no separate table for a bare-metal install, so treat them as the best documented guide. The optional Bot Screen feature, a virtual desktop the agent can use, asks for more: its guide suggests 4 GB for the desktop and 8 GB for comfortable browser use.

Past that, memory depends on what you switch on, not on a fixed floor:

• Browser and computer-use tools. The docs single out Chromium-based browser automation as the most memory-hungry feature.
• How many profiles and chat apps you run. Each profile is a separate agent with its own sessions and memory; the Docker guide notes that one container can host all profiles and shares the Python runtime between them. See Hermes Agent profiles.
• Disk growth. The Docker guide says the data volume grows with sessions and skills, which is why it suggests 2 GB or more. Sessions are kept in a SQLite database in the data directory.
• A local model. This dwarfs everything above, as the next section shows.

If you run the agent in Docker, --memory and --cpus let you cap it, and the Docker guide shows the flags. More on that in running Hermes Agent in Docker.

Local models versus cloud models

With a cloud provider, the model runs on someone else’s hardware and Hermes needs only a connection to it. With a local model your machine does the inference, so RAM, GPU memory and CPU speed all matter. Hermes normally rejects a model whose context window is below 64,000 tokens (LM Studio is the one exception, when you set the context length yourself), so set a local model up with at least that much room.

The documented numbers:

• Ollama guide. Minimum 8 GB of RAM for 3B models, recommended 32 GB or more for 27B and larger. Storage is 5 GB free at a minimum and 30 GB or more for several models. CPU is 4 cores at a minimum and 8 or more recommended. A GPU is not required, though an NVIDIA card with 8 GB or more of VRAM makes it much faster.
• CPU-only speed. The same guide says a 9B model on a modern 8-core CPU gives about 10 tokens a second, and a 31B model about 2 to 5, so a reply can take 30 to 120 seconds. It suggests raising HERMES_API_TIMEOUT for slow set-ups.
• Desktop Local Models. The app runs a managed llama.cpp server and checks each model against your hardware before you download it, showing whether it fits GPU memory, spills to system RAM or is too big. A GPU with 8 GB or more runs the small catalog models, and 16 GB or more runs the 27 to 35B models at high quality.
• Apple Silicon. The Mac guide estimates roughly 10 GB for a quantised 9B model at a 128K window. On an 8 GB Mac it advises a smaller model that still keeps at least 64K of context. Models in the 27B to 35B range need 32 GB or more of unified memory.

Backends and exact settings are in Hermes Agent with Ollama. A small local model can also be a weaker agent, since tool use leans on the model, so the hardware you can afford may decide which model you can use.

Desktop app, CLI, Docker, WSL2 and Android

Desktop app or CLI. Both drive the same agent, with the same config, keys, sessions and memory. The desktop app is a download for macOS (Apple Silicon) and Windows, and it bundles Python and its dependencies, so the first launch does not build a runtime. The CLI needs the installer. See Hermes Desktop for what the app adds.

Docker. Uses the official image on x86_64 or aarch64 and the 1 GB, 2 to 4 GB figures above. The data lives in a mounted volume, so you keep your agent when you replace the image.

WSL2. Hermes runs natively on Windows, including the dashboard’s embedded terminal, so WSL2 is a choice, not a requirement. It is an option if you prefer a Linux environment, and inside it Hermes behaves like Ubuntu. Keep your projects on the Linux side rather than under /mnt/c, which is much slower.

Android and Termux. A signed Termux package exists for aarch64 Android devices, but in 0.22.5 the docs flag that package as currently broken, with a repair under way. It is Tier 2, Android can end background processes, and other architectures are unsupported, so do not plan around a phone as your host.

Raspberry Pi and other ARM boards. The documentation does not mention Raspberry Pi by name. Linux on aarch64 is Tier 1 and the pinned Python and Node.js builds cover 64-bit ARM, so a 64-bit Linux image on a Pi falls inside the supported architecture list. That is an inference from the platform table, not a tested claim, and 32-bit ARM is not in the list. Memory is the likely limit on a small board.

Requirements for keeping it running

Chat apps and scheduled agent jobs work only while the gateway runs on a machine that is on and online, and the dashboard is a separate process that needs the machine on too. A laptop that sleeps cannot answer while it is asleep, and whether messages arrive after it wakes depends on the chat app. If you want one always on, a small always-on Linux machine or VPS meets the figures above, and the choice between that and a hosted agent is set out in self-hosting versus managed hosting.

Plan for a stable connection to your model provider, for updates, which you run with hermes update on a source install (Docker, Nix, Termux and the desktop app update through their own channels), and for your own backups of the data directory.

System requirements on ReadyHermes

On ReadyHermes your Hermes Agent runs on our servers, so there is nothing to size or install on your side. You do not need a particular operating system, a spare GPU or a computer that stays on; a browser is enough to use the workspace, and the same assistant can answer in Telegram, WhatsApp, Discord, WeChat or Lark.

A new assistant is ready in about 10 seconds, and the free trial lasts one hour. We do not publish per-assistant memory or disk figures on this page, so the numbers above describe self-run Hermes, not what an assistant here is given. The Ollama and GPU rows describe running a model on your own machine, which is not something you manage here. To compare the effort, read managed Hermes Agent hosting.