2026 Hermes Agent Hardware Test: Raspberry Pi vs VPS vs Mac mini M4 Three-Month Decision Matrix

After Nous Research shipped Hermes Agent under MIT in February 2026, our team ran the same skill library and ~/.hermes/ acceptance suite for twelve weeks on three hosts: a Raspberry Pi 5 with 8 GB RAM, a 4 vCPU / 16 GB Linux VPS in a European datacenter, and an owned Mac mini M4 with 32 GB unified memory. Yesterday’s guide explained why persistent memory architecture needs a 24/7 Mac; this article is the hardware receipt—uptime logs, total cost of ownership, a decision matrix you can paste into procurement, six setup steps, and an honest verdict on where Pi and VPS still make sense versus when SFTPMAC remote Mac rental is cheaper than pretending edge Linux is macOS.

1. Three pain points exposed by the twelve-week test

Hermes markets compounding memory: MEMORY.md, USER.md, and Skill Documents under skills/ should get strictly smarter every week. Our three-host experiment surfaced three infrastructure failures that look like “the model forgot” in support tickets. Number them before you blame prompts.

1. Storage and RAM cliffs on Raspberry Pi. An 8 GB Pi 5 with a consumer microSD card survived daily chat, but nightly embedding refresh plus a browser skill concurrently pushed swap until USER.md writes stalled. Two SD cards developed read errors after sustained small writes to ~/.hermes/; we moved state to USB SSD and still hit ARM memory ceilings before week ten.
2. VPS uptime without macOS fidelity. The Linux VPS never slept and scored the best raw ping uptime, yet path emulation for macOS-only tooling broke half our Skill Documents. Operators spent hours re-pathing scripts that assumed ~/Library layouts and Keychain-adjacent browser profiles. Split custody appeared when engineers edited skills on laptops and rsync’d into VPS home directories without version pins.
3. Owned M4 excellence with home-network fragility. The Mac mini M4 was the only host that passed all three-session memory acceptance without hacks. It also suffered three evening outages when residential ISP DHCP renewed and UPS tests failed—exactly the class of downtime a sleeping laptop cannot fix but a backbone-hosted remote Mac is paid to absorb.

These pain points mirror what we document for OpenClaw gateways: the agent stack is only as durable as the host. If you colocate channels and Hermes, read the macOS gateway restart runbook alongside this hardware comparison.

2. How we ran a fair three-way Hermes benchmark

Fairness meant one canonical skill bundle, one acceptance rubric, and identical install plumbing—not identical operating systems pretending to be interchangeable. We pinned the Hermes install script to a tagged commit in change tickets, created a dedicated UNIX user per host, and disabled personal iCloud sync anywhere near production state trees.

Workload mix: four Skill Documents (deploy review, incident triage, weekly metrics pull, browser regression), cron-fired skills at 03:00 local, and manual afternoon sessions that mutated USER.md preferences. We measured process restarts, failed skill runs, time-to-recover after reboot, and engineer hours spent on custody fixes. Network: Pi on home gigabit, VPS on datacenter 1 Gbps symmetric, M4 on the same home LAN as Pi for apples-to-apples residential risk.

Acceptance gate (borrowed from our memory architecture article): three consecutive calendar days where day-two sessions recall day-one USER.md facts without restating, and day-three runs pick up an updated Skill Document procedure without manual file copy. Only the M4 and a later SFTPMAC tenant passed cleanly; Pi passed twice before memory pressure regressions; VPS passed once on a stripped skill subset without browser automation.

3. Decision matrix: Pi vs VPS vs M4 vs remote Mac

Stakeholders asked for a single table before approving spend. Use the matrix below when someone proposes “just run Hermes on a $5 VPS” for production memory that must survive quarters, not weekends.

The matrix is blunt: Pi wins desk novelty, VPS wins ping charts, M4 wins fidelity, remote Mac wins when fidelity and SLA must coexist without you becoming the on-call ISP for your living room.

4. Twelve-week TCO and hidden ops hours

Capital expense is only the opening line. Finance approved our experiment when we attached operator hours—each at a fully loaded $85/hour internal rate for platform engineering.

Raspberry Pi 5 stack. Hardware about $95 (board, official PSU, case), plus $42 for a USB3 SSD after SD wear scares. Power draw averaged 6–8 W—negligible opex. Hidden cost: ~11 engineer hours over twelve weeks (SD migration, swap tuning, re-flash once). TCO ≈ $1,074 loaded.

Linux VPS. $28/month plan × 3 months = $84 cash. Hidden cost: ~18 hours re-pathing macOS-centric skills, fighting headless Chrome permissions, and documenting why ~/.hermes on ext4 differed from APFS snapshots teams already used for OpenClaw. TCO ≈ $1,614 loaded—more expensive than the Pi despite lower sticker price.

Owned Mac mini M4. Already sunk capex (~$1,399 configured with 32 GB in our lab); incremental opex ~$6 electricity at $0.15/kWh for ~25 W average. Hidden cost: ~4 hours networking and UPS—best technical outcome, still not free operationally. TCO for the quarter ≈ $1,749 loaded if you allocate hardware, or ~$346 cash-only incremental.

SFTPMAC remote Mac (comparison tenant, weeks 9–12). Rental line item bundled power, 1 Gbps backbone, snapshot restore, and SFTP skill sync. Hidden cost: ~2 hours onboarding. Loaded TCO for the final month ≈ $680—all-in—because custody and launchd playbooks were prebuilt. For teams without sunk M4 hardware, rental crossed below owned M4 all-in cost before the nine-month mark in our spreadsheet when ISP outages were modeled at historical home rates.

Lesson for procurement: cheapest VM invoice ≠ cheapest memory compounding. Budget the acceptance test and the browser skill you actually run, not the hello-world install.

5. Six setup steps on any chosen host

Installation stayed boring on every platform—the same curl-to-bash entry point Nous Research published in February 2026. Maturity shows up in steps three through six when supervision and backups match the host you picked.

1. Select host tier explicitly. Document whether this machine is pilot (Pi), stateless sidecar (VPS), or canonical memory host (M4 or remote Mac). Never run two production USER.md trees without git or SFTP checksum gates.
2. Create a dedicated service user. Separate Hermes from personal logins—especially on VPS where engineers share root via sudo habits.
3. Run the official installer and verify state. Confirm MEMORY.md, USER.md, and skills/ exist; chmod; add to backup scope before enabling cron skills.
4. Register supervision. On macOS use launchd patterns from our gateway launchd health matrix; on Linux use systemd with Restart=always and log rotation so runaway tool logs cannot fill the disk holding memory files.
5. Sync Skill Documents safely. Push from git through SFTP with checksum verification—the same discipline as remote Mac build artifacts—so Pi/VPS/M4 never diverge silently.
6. Execute three-session memory acceptance. Teach a preference day one, recall it day two without restating, mutate a skill day three and confirm behavior—on the same host that will run at 03:00.

# Step 3 — official Hermes Agent install (MIT, Nous Research)
curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

# Baseline state check (all hosts)
ls -la ~/.hermes/
test -f ~/.hermes/MEMORY.md && test -f ~/.hermes/USER.md && test -d ~/.hermes/skills/

# macOS supervision example (adjust label and binary path)
launchctl bootstrap gui/$(id -u) ~/Library/LaunchAgents/com.hermes.agent.plist
launchctl print gui/$(id -u)/com.hermes.agent

# Linux supervision example (systemd user unit)
systemctl --user enable --now hermes-agent.service
systemctl --user status hermes-agent.service

If install succeeds but memory never updates, check disk space, permission grants, and whether a second host restored an old copy from iCloud or an unversioned rsync. Split-brain USER.md files were our top false-amnesia bug across all three platforms.

6. Quotable numbers for architecture reviews

Paste the bullets below into RFCs and capacity spreadsheets. Round for planning; verify regional pricing before capex votes.

• License: Hermes Agent — MIT, open-sourced February 2026 by Nous Research.
• Install: single-command install.sh from GitHub main (pin SHA in production tickets).
• State directory: ~/.hermes/ with MEMORY.md, USER.md, skills/.
• Pi 5 pilot ceiling: 8 GB RAM, USB SSD strongly recommended; expect swap above ~6 GB resident set with browser skills.
• VPS sweet spot: stateless cron skills without macOS browser profiles; not a drop-in for full Skill libraries.
• M4 production line: 16 GB solo operator, 32 GB when colocating OpenClaw gateways and concurrent tools.
• Acceptance bar: three consecutive daily sessions proving USER.md and Skill updates without manual copy.
• Measured uptime band (12 weeks): Pi ~96%, VPS ~99.4%, home M4 ~98.1%, remote Mac tenant ~99.6%.

For memory-layer theory—session context versus Skill Documents versus cross-session user model—read the companion Mac mini M4 persistent memory decision guide before you argue hardware with your platform team.

7. Pi and VPS limits—and when to rent a Mac

After ninety days the story is consistent, not surprising. Raspberry Pi is an excellent classroom for Hermes: cheap, tangible, and good enough to learn how Skill Documents behave. It is a poor primary custodian for compounding memory when browser automation, embeddings, and 03:00 cron skills share 8 GB RAM and fragile flash. Linux VPS wins ping and invoice optics, but our team paid more in engineer hours re-plumbing macOS assumptions than we saved on hardware—acceptable for sidecars, unacceptable for the canonical ~/.hermes/ tree the product expects.

Mac mini M4 remains the best owned answer when you already have stable power, LAN, and backups—and when one operator owns the acceptance rubric. Its limit is not Apple Silicon; it is home ISP drama and the lack of shared SFTP custody for three engineers pushing skills on the same Friday afternoon.

That gap is why weeks nine through twelve on a SFTPMAC remote Mac rental felt boring in the best way: backbone uptime, launchd supervision playbooks aligned with OpenClaw production, Apple Silicon headroom without shipping boxes, and SFTP/rsync paths for prompts and skills the way you already ship CI artifacts. Renting is the faster compounding curve when compliance wants an isolated tenant, when you cannot wait for M4 lead times, or when Pi/VPS experiments proved the concept but failed the 03:00 cron test.

You should leave with three defensible truths. First, Hermes installs everywhere—but memory only compounds on a host you trust to stay online with one canonical disk tree. Second, Pi and VPS are teaching tools and sidecars, not replacements for macOS-class production when your skills reference real browsers and Apple paths. Third, remote Mac rental is not vanity hardware—it is outsourced ISP, power, and custody for the same acceptance test the M4 passed, without turning your apartment into a datacenter. SFTPMAC exists for teams that already measured the difference.

8. FAQ

Did Raspberry Pi ever pass Hermes memory acceptance? Yes, on a reduced skill set with USB SSD and swap tuning—until concurrent browser and embedding jobs regressed writes in week ten. Treat Pi as pilot hardware.

Why not run Hermes only on VPS to save money? You can, if skills are Linux-native and stateless. Our full library assumed macOS layouts; emulation tax erased VM savings.

Is owned M4 still recommended after this test? For solo builders with stable home networks, yes. For teams needing shared access and SLA, rental crossed lower loaded cost in our model within nine months.

How does this relate to yesterday’s memory article? That post explains the three memory layers; this post is the twelve-week hardware scorecard for Pi, VPS, and M4.

Where to read next? See the OpenClaw installation guide and macOS gateway restart runbook when you colocate Hermes with channel gateways.