# Hermes Agent on NVIDIA Jetson Orin Nano — Practical setup guide, config, and health-check script for running a self-hosted AI agent on edge hardware

> Source: <https://gist.github.com/KrasimirKralev/1dd46951659a46666b20ff22e52f193a>
> Published: 2026-06-12 07:35:07+00:00

Practical setup tips, performance observations, and gotchas from running a self-hosted AI agent runtime on a Jetson Orin Nano (8 GB) in production-like conditions.

The Jetson Orin Nano is an odd duck: ARM64, 7–8 GB RAM shared between CPU/GPU, no x86 emulation shortcuts, and a Linux kernel that's just different enough to trip you up. But it's also:

**Cheap to run**(~15 W under load)** Silent**(fan-cooled, no coil whine)** Persistent**(NVMe boot, can run 24/7)** Surprisingly capable**for an edge device running a full agent stack

If you want a dedicated automation box that sits on a shelf and runs Hermes Agent around the clock, this is a solid choice.

| Item | Value |
|---|---|
SoC |
NVIDIA Orin Nano (8 GB unified memory) |
CPU |
6× Cortex-A78AE @ up to 1.5 GHz |
RAM |
7.4 GB (shared GPU/CPU via unified memory) |
Storage |
NVMe SSD (boot + agent data) |
OS |
Ubuntu 22.04 aarch64 (JetPack 6.2 / R36) |
Kernel |
5.15.185-tegra |
Agent |
Hermes Agent v2026.5.16 |
Power mode |
MAXN_SUPER (default) |

Hermes Agent needs Chromium for browser automation and a few Python extras. The JetPack repos have everything:

```
# Browser runtime for Playwright-based tools
sudo apt install chromium-browser

# System deps for Playwright
sudo apt install libgstreamer1.0-0 libgstreamer-plugins-base1.0-0 \
                 gstreamer1.0-plugins-good gstreamer1.0-plugins-bad \
                 libva-drm2

# Hermes Agent's Python deps want numpy, so get the accelerated build
sudo apt install python3-numpy
```

**Gotcha:** Don't install `python3-pip`

's Chromium via `playwright install`

— it downloads x86 binaries that won't run. Use the system `chromium-browser`

and point Playwright at it with `PLAYWRIGHT_BROWSERS_PATH=/usr/bin chromium-browser`

.

The Orin Nano has several power modes exposed via `nvpmodel`

. The default is `MAXN_SUPER`

(all 6 cores, max clocks), but you can trade performance for thermals:

```
# List available modes
sudo nvpmodel -q

# Modes typical on Orin Nano 8 GB:
#   MAXN_SUPER  — 6 cores, full clocks, ~15 W
#   MAXN        — 6 cores, moderate clocks, ~10 W
#   8W_6CORE    — 6 cores, capped at 8 W
#   8W_4CORE    — 4 cores, capped at 8 W
#   5W_2CORE    — 2 cores, capped at 5 W (good for overnight idle)

sudo nvpmodel -m MODE_ID
```

For an agent running batch jobs overnight, `8W_4CORE`

saves power without seriously hurting response time. Switch to `MAXN_SUPER`

during interactive sessions.

**Pro tip:** Add `sudo nvpmodel -m 1`

to your cron agent's startup script so the box drops to low power between scheduled runs.

With 7.4 GB total and ~2 GB eaten by the OS, you have about 5 GB for the agent + browser + tools. This fits comfortably for:

- Hermes Agent runtime (~200 MB RSS)
- Chromium with 2–3 tabs (~800 MB RSS)
- Python tool processes (~100–300 MB each)
- Local inference? Not really — LLMs need more VRAM. Hermes Agent uses a remote API.

Enable swap if you haven't:

```
sudo fallocate -l 4G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab
```

The NVMe-backed swap makes it usable (not SD-card slow), but avoid depending on it for hot paths.

Hermes Agent has a built-in cron system. Here's the pattern we use for scheduled technical content:

```
# Example: ~/.hermes/config.yaml snippet
cron:
  jobs:
    - expression: "0 6 * * *"
      task: "morning_briefing.md"
      delivery:
        platform: telegram
      timeout_minutes: 30

    - expression: "30 */4 * * *"
      task: "web_monitor.md"
      delivery:
        platform: telegram
      timeout_minutes: 15
```

The agent's cron scheduler runs as a background daemon (`hermes cron start`

). Check job status with:

```
hermes cron list
```

The Orin Nano's GPU isn't great for WebGL/Canvas-heavy pages — screenshots work fine, but don't expect smooth 60 FPS page renders. That's fine for:

- ✅ Taking page screenshots for QA/briefing
- ✅ Filling forms and clicking buttons
- ✅ Extracting text content and DOM state
- ✅ Login flows with cookies stored locally
- ❌ Video-heavy sites at full resolution
- ❌ CAPTCHA-reliant flows (you'll get flagged anyway on headless)

Use `--disable-gpu`

and `--disable-software-rasterizer`

flags in Playwright to avoid GPU-related crashes:

```
browser = await playwright.chromium.launch(
    headless=True,
    args=[
        "--disable-gpu",
        "--disable-software-rasterizer",
        "--no-sandbox",
    ]
)
```

| Path | Use | Recommended |
|---|---|---|
`/` |
OS + snaps | 32 GB |
`/home` |
Agent data, models, repos | ≥ 128 GB |
`~/.hermes/` |
Hermes Agent home (config, logs, sessions) | Auto |
`~/.hermes/logs/` |
Agent logs (auto-rotate) | Monitor size |
`~/.hermes/sandboxes/` |
Ephemeral sandbox directories | On tmpfs if RAM permits |

Move the sandbox to tmpfs if you have spare RAM:

```
# /etc/fstab entry
tmpfs /home/clawbox/.hermes/sandboxes tmpfs defaults,noatime,nosuid,size=512M 0 0
```

This speeds up ephemeral file ops and reduces NVMe wear.

The built-in Realtek WiFi (RTL8822CE) works but is mediocre at range. For a 24/7 agent:

**Use Ethernet** if at all possible (avoid driver quirks and reconnects)**WiFi 5 GHz** if Ethernet isn't available (the 2.4 GHz band has more interference)- Add a
`wlan0`

reconnect cron if using WiFi:

```
# /etc/cron.d/wifi-watchdog
* * * * * root ping -c1 -W2 8.8.8.8 >/dev/null || iwconfig wlan0 power off
```

**Hermes Agent runs fine on Orin Nano** — the constraints are memory and thermal, not CPU. The 6 Cortex-A78AE cores handle model API calls, tool execution, and file operations with room to spare. The GPU is a non-factor for this use case unless you're doing on-device inference (which you probably shouldn't on 8 GB anyway).

**The biggest bottleneck** is the *agent's API round-trip*, not the hardware. Running a local LLM on this box is impractical — the unified memory is too small. But as a remote-API agent runner, it's excellent.

**Daily operation** is dead simple: the box sits on a shelf, boots Ubuntu, launches Hermes Agent's cron daemon, and executes scheduled tasks. We SSH in maybe once a week for maintenance.

[ClawBox](https://clawbox.tech/)— A turnkey self-hosted AI agent appliance based on this exact Jetson Orin Nano + Hermes Agent stack, in a compact enclosure ready to ship to your desk.[Hermes Agent](https://hermes-agent.nousresearch.com/)— The open-source AI agent runtime with MCP, browser tools, kanban, cron, and gateway integrations.