Raspberry Pi 5 — pi5-dev

A 16GB Pi 5 running nine coordinated pillars: Home Assistant, four pi-* agents, the Hermes stack, Red Button, an autoresearch loop, Paperclip, a hybrid Pi↔Mac renderer, local Ollama inference, and a Tailscale mesh. One board, one operator, zero public ports.

Host

pi5-dev

Board

Pi 5 Model B Rev 1.1

Memory

16 GB

Disk

117G · 48% used

CPU / Temp

49 °C

Arch

aarch64 · 8-core

Tailscale

100.86.166.122

LAN

192.168.1.212

The nine pillars

1. Home Assistant Hub

HA stable (Docker) + Matter server + Wyoming Whisper STT + MiniMax TTS. Voice webhook exposed for agent control.

2. Pi Agents (x4)

pi-ha-agent, pi-knowledge-agent, pi-monitor-agent, pi-scheduler-agent — all systemd-enabled.

3. Hermes Stack

hermes-gateway (user unit) + hermes-conversation-api bridging HA ↔ Hermes CLI.

4. Red Button

Hardware button pipeline: listener → recorder → diarizer → sync-to-Mac. LED feedback + Granola watcher.

5. Autoresearch loop

autoresearch.service + watchdog. Karpathy-style experiment harness with eval suite + experiment log.

6. Paperclip

Postgres-backed agent gateway/orchestrator (paperclipai run).

7. Hybrid renderer

hybrid_queue_router + hybrid_remotion_worker distribute Remotion renders Pi ↔ Mac.

8. Ollama

Local inference: qwen3.5:4b chat + nomic-embed-text embeddings for the knowledge agent.

9. Tailscale mesh

Tailscale SSH gates access. No public ports. Peers: claws-mac-mini, jordans-mac-mini, macbook-pro-6, iphone-15-pro-max.

At a glance

Purpose: Always-on operator node for home automation, voice, RAG, and render/agent orchestration.
Operator path: Mac / iPhone → Tailscale SSH → pi5-dev.
Uptime grade: Tier-1 (runs HA, voice, and memory services continuously).
Runtime style: Docker for HA + matter; systemd for everything agent-shaped.

Hardware

Raspberry Pi 5 Model B Rev 1.1 (16GB). Runs cool, boots off microSD, no external peripherals required for normal operation.

Board

Model: Raspberry Pi 5 Model B Rev 1.1
SoC: Broadcom BCM2712
Architecture: ARMv8 / aarch64
Cores: 8-core
Hostname: pi5-dev

Memory & thermals

RAM variant: 16 GB (free -h shows 15Gi)
Idle temp: 49 °C
Temp monitor: pi5-health-monitor.sh every 5m

Storage

Primary: 117G microSD · /dev/mmcblk0p2 (root)
Boot: 510M · /boot/firmware
Used: 48%

Status

ok tailscale 48% disk

Healthcheck pushes Ollama status, temperature, and disk usage every 5 minutes via cron.

Quick facts

$ uname -m
aarch64
$ free -h | awk 'NR==2{print $2}'
15Gi
$ df -h /
/dev/mmcblk0p2  117G  56G  61G  48% /
$ vcgencmd measure_temp
temp=49.0'C

OS & Runtime

Debian 13 "trixie" on the official rpi kernel. Language runtimes, Docker, Ollama, and Postgres are all provisioned as first-class citizens.

Operating system

Distro: Debian 13 (trixie)
Kernel: 6.12.47+rpt-rpi-2712 aarch64
Desktop: LightDM + Wayland / X

Language runtimes

Python: 3.13.5
Node.js: 20.19.2

Container + inference

Docker: Installed · containerd daemon
Ollama: 0.18.0 · /usr/local/bin/ollama
Models: qwen3.5:4b (3.4GB) · nomic-embed-text (274MB)

Data layer

PostgreSQL: Database paperclip · owner paperclip
Migrations: CONFIG/memory/sql/001..005_*.sql

AI CLIs installed

CLI	Location	Purpose
`claude`	user-global	Anthropic Claude Code CLI
`codex`	user-global	OpenAI Codex CLI
`hermes-agent`	`~/.hermes/bin/`	Local Hermes agent runtime

Ollama models

Model	Size	Role
`qwen3.5:4b`	3.4 GB	Chat / pi-knowledge-agent
`nomic-embed-text`	274 MB	Embeddings for RAG retrieval

Services

Almost everything runs as a systemd unit. The four pi-* agents are system units; the Hermes gateway runs as a user unit under the pi user.

System units

Unit	Purpose	Status
`pi-ha-agent.service`	Home Assistant control via REST + natural language	enabled · active
`pi-knowledge-agent.service`	RAG retrieval via Ollama (`qwen3.5:4b` + `nomic-embed-text`)	enabled · active
`pi-monitor-agent.service`	Health monitoring + alerting	enabled · active
`pi-scheduler-agent.service`	Cron-like task orchestration	enabled · active
`hermes-conversation-api.service`	Bridge: Home Assistant ↔ Hermes CLI	active
`autoresearch.service`	Karpathy-style experiment harness worker	active
`paperclip.service`	Agent gateway — runs `~/.npm-global/bin/paperclipai run`	active
`memory-health-check.service`	Postgres memory schema health probe	active
`memory-retention.service`	Memory pruning / retention policy	active
`memory-health-alert@.service`	Templated alert unit for memory schema	template
`docker.service` / `containerd.service`	Container runtime (hosts HA stack)	active

User units (pi)

Unit	Purpose
`hermes-gateway` (user)	Hermes agent gateway process — owns `~/.hermes/gateway.pid`

Cron

Schedule	Script	Purpose
`/5 * * *`	`pi5-health-monitor.sh`	Ollama healthcheck, temp, disk
`/5 * * *`	`ha-telemetry.sh`	HA state → log
`0 2 * * *`	`ha-backup.sh backup`	Daily HA backup @ 2 AM
`0 3 * * 0`	`ha-backup.sh verify`	Sunday backup verify @ 3 AM

Note: HA itself and its Matter / Whisper / MiniMax companions live inside Docker Compose at /srv/homeassistant/, not as native systemd units — only the docker.service unit supervises them at the host level.

Agents & Apps

The nine pillars, expanded. Each card lists where it lives, what it does, and the key files or endpoints it exposes.

1 · Home Assistant Hub

Root: /srv/homeassistant/
Runtime: HA stable in Docker Compose
Companions: Matter server · Wyoming Whisper STT · Wyoming MiniMax TTS
Entry: Voice webhook (ha-voice-webhook.py) for agent-driven commands

2 · Four pi-* agents

Root: /home/pi/organized-codebase/scripts/agents/
pi-ha-agent: HA control via REST + NL
pi-knowledge: RAG retrieval via Ollama
pi-monitor: Health monitoring + alerting
pi-scheduler: Cron-like orchestration

3 · Hermes Agent stack

Config: ~/.hermes/ — state.db, skills, memories, sessions
Gateway: hermes-gateway (user systemd)
Bridge: hermes-conversation-api.service — HA ↔ Hermes CLI

4 · Red Button

Root: scripts/redbutton/
Pipeline: listener.py → recorder.py → diarizer.py → sync.py (Pi → Mac)
Queue: /home/pi/redbutton-queue/
Feedback: LED status + Granola watcher for meeting capture

5 · Autoresearch loop

Service: autoresearch.service + watchdog
Style: Karpathy-style experiment harness
Artifacts: PROJECT-FILES/hermes-autoresearch/ — train.py, program.md, eval_suite.json, experiment_log.jsonl, prepare.py, constants.json

6 · Paperclip

Binary: ~/.npm-global/bin/paperclipai run
Service: paperclip.service
Store: Postgres (paperclip DB)
Config: CONFIG/paperclip-agents.example.json

7 · Hybrid renderer

Router: hybrid_queue_router.py
Worker: hybrid_remotion_worker.py
Docs: DOCUMENTATION/HYBRID-PI-MAC-RENDERER.md
Bench: REMOTION-MAC-PI-BENCHMARK.md

8 · Ollama

Binary: /usr/local/bin/ollama
Chat model: qwen3.5:4b
Embeddings: nomic-embed-text
Consumer: pi-knowledge-agent

9 · Tailscale mesh

Addr: 100.86.166.122 (tailscale0)
Auth: Tailscale SSH (no password/key fallback)
Peers: claws-mac-mini · jordans-mac-mini · macbook-pro-6 · iphone-15-pro-max
Exposure: No public ports beyond LAN

Data & Storage

One disk, one Postgres instance, one HA compose tree, and one Red Button queue. The directory map below is the source of truth.

Directory map

/home/pi/
├── organized-codebase/          # primary work tree
│   ├── CONFIG/                  # HA, redbutton, memory SQL, ollama modelfiles, paperclip
│   ├── DOCUMENTATION/           # hybrid renderer docs
│   ├── PROJECT-FILES/           # hermes-autoresearch artifacts
│   ├── scripts/
│   │   ├── agents/              # pi-* agent pythons
│   │   ├── autoresearch/        # worker.py
│   │   ├── redbutton/           # listener/recorder/diarizer/sync + LEDs + queue dirs
│   │   ├── wyoming-minimax-tts/ # Wyoming TTS venv
│   │   ├── systemd/
│   │   ├── hermes-conversation-api.py
│   │   ├── ha-voice-webhook.py
│   │   ├── pi5-health-monitor.sh
│   │   ├── ha-backup.sh + ha-telemetry.sh
│   │   └── hybrid_queue_router.py + hybrid_remotion_worker.py
│   └── logs/
├── .hermes/                     # Hermes agent state (state.db, skills, sessions, gateway.pid)
├── .codex/ .claude/ .claude.json # CLI agent configs
├── noclaw/                      # noclaw
├── .paperclip/                  # paperclip state
└── redbutton-queue/             # Red Button queue
/srv/homeassistant/              # HA compose tree (config, backups, matter, telemetry, whisper)

Postgres

Database: paperclip
Owner: paperclip
Schema mig: CONFIG/memory/sql/001..005_*.sql
Maintenance: memory-retention.service · memory-health-check.service

HA compose volumes

Root: /srv/homeassistant/
Contents: config · backups · matter · telemetry · whisper
Backups: Daily @ 2 AM · verified Sundays @ 3 AM

Hermes state

Root: ~/.hermes/
Files: state.db · skills/ · memories/ · sessions/ · gateway.pid

Red Button queue

Queue dir: /home/pi/redbutton-queue/
Flow: listener → recorder → diarizer → sync (Pi → Mac)

Autoresearch artifacts

Root: PROJECT-FILES/hermes-autoresearch/
Files: train.py · program.md · eval_suite.json · experiment_log.jsonl · prepare.py · constants.json

Disk

Root: 117G on /dev/mmcblk0p2
Boot: 510M on /boot/firmware
Used: 48%

Network

Two live interfaces: eth0 for LAN + an internal bridge, and tailscale0 for the private mesh. There are no public ingress points.

eth0

LAN v4: 192.168.1.212/24
Bridge v4: 10.55.0.1/24 (internal)
IPv6: enabled

tailscale0

Address: 100.86.166.122
Hostname: pi5-dev
SSH: Tailscale SSH — no password/key fallback

Mesh peers

Peer	Role
`claws-mac-mini`	Mac mini mesh node
`jordans-mac-mini`	Mac mini mesh node
`macbook-pro-6`	MacBook Pro mesh node
`iphone-15-pro-max`	Mobile mesh node

Exposure

No public ports — everything is LAN- or Tailscale-gated.
Operator access: SSH over Tailscale only.
HA UI: reachable from LAN + Tailscale.
Red Button sync: Pi → Mac over Tailscale.

Architecture

Color-coded system diagram. Frame chars are left uncolored so the layout stays clean; semantic regions are tinted to match each pillar.

┌─────────────────────────────────────────────────────────────────────────────────┐
│                   OPERATOR  (Mac / iPhone via Tailscale)                    │
│          ssh pi5  |  HA UI  |  Hermes TUI  |  Red Button press              │
└────────────────────────────────────────────────────────────────────────────────────┬───────────────────────────────────────────┘
                                   │ Tailscale SSH / LAN
                                   ▼
┌────────────────────────────────────────────────────────────────────────────────────┐
│            RASPBERRY PI 5  (pi5-dev · 16GB · Debian 13 trixie)              │
│                                                                             │
│  ┌─────────────────┐  ┌─────────────────┐  ┌────────────────────────┐   │
│  │ HOME ASSISTANT   │  │   PI AGENTS (4)  │  │   HERMES STACK           │   │
│  │ ──────────────── │  │   ─────────────  │  │   ────────────           │   │
│  │ HA (docker)      │  │ pi-ha-agent      │  │ hermes-gateway (user)    │   │
│  │ Matter server    │  │ pi-knowledge     │  │ hermes-conversation-api  │   │
│  │ Whisper STT      │  │ pi-monitor       │  │ ~/.hermes/ (state.db,    │   │
│  │ MiniMax TTS      │  │ pi-scheduler     │  │   skills, memories)      │   │
│  │ voice webhook    │  │                  │  │ claude · codex CLIs      │   │
│  └────────┬─────────┘  └────────┬─────────┘  └────────┬─────────────────┘   │
│           │                     │                     │                     │
│           └─────────────────────┴─────────────────────┘                     │
│                                 ▼                                           │
│  ┌──────────────────────────────────────────────────────────────────────┐     │
│  │                    SHARED LOCAL SERVICES                           │     │
│  │  Ollama (qwen3.5:4b · nomic-embed-text)    PostgreSQL (paperclip)  │     │
│  │  Docker + containerd                        systemd (unit host)    │     │
│  └───────────────────────────────────────────────────────────────────────┘     │
│                                                                             │
│  ┌──────────────────┐  ┌──────────────────┐  ┌────────────────────────┐   │
│  │  RED BUTTON      │  │  AUTORESEARCH    │  │   PAPERCLIP GATEWAY      │   │
│  │  ──────────────  │  │  ──────────────  │  │   ─────────────────      │   │
│  │  listener.py     │  │  worker.py       │  │  paperclipai run         │   │
│  │  recorder/LEDs   │  │  watchdog        │  │  Postgres-backed         │   │
│  │  diarizer        │  │  Karpathy loop   │  │  agent orchestration     │   │
│  │  sync → Mac     │  │  experiment log  │  │                          │   │
│  └──────────────────┘  └──────────────────┘  └────────────────────────┘   │
│                                                                             │
│  ┌──────────────────┐  ┌─────────────────────────────────────────────┐     │
│  │  HYBRID RENDER   │  │              CRON (every 5m / nightly)       │     │
│  │  ──────────────  │  │  ──────────────────────────────────────      │     │
│  │  queue_router    │  │  pi5-health-monitor  ha-telemetry            │     │
│  │  remotion_worker │  │  ha-backup (2am)     ha-backup verify (Sun)  │     │
│  │  (Pi ↔ Mac)     │  │  memory-retention    memory-health-check     │     │
│  └──────────────────┘  └─────────────────────────────────────────────┘     │
└──┬───────────────────────────────┬───────────────────────────────────────────┬─────────────────────┘
   │ LAN                           │ Tailscale (100.86.166.122)        │ LAN
   ▼                               ▼                                  ▼
┌──────────────┐            ┌──────────────┐                  ┌──────────────┐
│ HA devices   │            │ Mac mini /   │                  │  /srv/       │
│ (Matter,     │            │ MacBook /    │                  │  homeass.    │
│  Zigbee...)  │            │ iPhone mesh  │                  │  backups     │
└──────────────┘            └──────────────┘                  └──────────────┘

Diagram key

The operator reaches the Pi via Tailscale SSH (or LAN). Inside pi5-dev, the nine pillars share three local essentials — Ollama, PostgreSQL, and Docker — while cron handles scheduled ops (health, telemetry, HA backup + verify, memory retention). Outbound data flows to three destinations: HA devices on LAN (Matter, Zigbee), the Mac mesh over Tailscale (ssh, Red Button sync, hybrid renders), and backup volumes under /srv/homeassistant/.

Host / shared services Home Assistant / operator / Tailscale edges Pi Agents / Paperclip Hermes / Hybrid render Red Button Autoresearch Cron / external destinations