How to Use OpenClaw as an SSH Session Manager on Raspberry Pi

SecurityScorecard's February 2026 scan found over 135,000 OpenClaw instances running on publicly accessible IP addresses across 82 countries, with more than 50,000 still vulnerable to remote code execution via CVE-2026-25253. The root cause was a default configuration that binds to all network interfaces on port 8080 with no authentication. Running OpenClaw on a Raspberry Pi at home, accessible only through SSH, sidesteps this entire attack surface.

A Raspberry Pi draws roughly 6W under load. That translates to about $4 per month in electricity for a device that stays online 24/7 as your SSH session management hub. The Pi doesn't run LLMs locally. It acts as an orchestration layer, delegating reasoning to cloud APIs (Anthropic, OpenAI, Google) while managing tool calls, channel integrations, and persistent SSH connections to your other machines.

Traditional SSH workflows break at scale. You open a terminal, connect to a server, run commands, then lose context when the connection drops. Multiplexers like tmux preserve sessions, but you still need to remember which server has which session, manually reattach after disconnections, and mentally track state across hosts. An OpenClaw agent on a Pi handles this through natural language: "check disk usage on all three staging servers" becomes a single instruction that the agent routes, executes, and summarizes.

A Raspberry Pi 5 with 8 GB RAM is the recommended baseline. The Pi 4 with 4 GB works for light workloads but struggles when the agent manages concurrent SSH sessions to multiple hosts. Avoid the 2 GB variants.

SD cards create I/O bottlenecks for OpenClaw's frequent SQLite writes. The official Raspberry Pi M.2 HAT with a budget NVMe drive costs under $30 and eliminates this problem. Use the official 27W USB-C power supply to avoid under-voltage warnings when an SSD and active cooler draw power simultaneously.

Flash and Configure Pi OS Lite

Open the Raspberry Pi Imager and select Raspberry Pi OS Lite (64-bit). The 64-bit version is required. Before flashing, configure these settings in the Imager's advanced options:

• Hostname: pick something descriptive like gateway-host
• Enable SSH with password authentication (you will switch to key-based auth after first boot)
• Set your username and password
• Configure WiFi credentials if you are not using Ethernet

After the Pi boots, connect from your workstation:

ssh youruser@gateway-host

Update the system and reduce the attack surface immediately:

sudo apt update && sudo apt upgrade -y
echo 'gpu_mem=16' | sudo tee -a /boot/config.txt
sudo systemctl disable bluetooth

Setting gpu_mem=16 reclaims video memory since there is no display attached. Disabling Bluetooth removes an unnecessary service and its associated attack surface.

Lock Down SSH Access

Switch from password authentication to SSH keys before doing anything else. On your workstation, generate a key pair if you do not have one, then copy the public key to the Pi:

ssh-copy-id youruser@gateway-host

Then disable password authentication on the Pi by editing /etc/ssh/sshd_config:

PasswordAuthentication no
PubkeyAuthentication yes

Restart the SSH daemon with sudo systemctl restart sshd. From this point forward, only machines with your private key can connect.

OpenClaw's gateway runs as a systemd user service on the Pi. The official documentation recommends enabling user lingering so the service survives SSH disconnections:

sudo loginctl enable-linger "$(whoami)"

This single command is the difference between a gateway that dies when you close your laptop and one that runs indefinitely. Combined with a systemd drop-in configuration that sets Restart=always and RestartSec=2, your OpenClaw gateway recovers automatically from crashes, OOM kills, and reboots.

Session Persistence with tmux

OpenClaw manages its own sessions internally, but wrapping the gateway process in a tmux session gives you a fallback inspection layer. If the systemd service logs are not enough, you can attach to the tmux session and watch the gateway's stdout in real time. The official installation docs call tmux "optional but recommended for terminal session management."

The more important persistence mechanism is OpenClaw's built-in session system. The gateway maintains session state in its local database, which means your conversations, tool call history, and agent context survive process restarts. When you SSH into the Pi tomorrow morning, your agent remembers what it was working on yesterday.

Accessing the Dashboard Securely

The OpenClaw dashboard binds to localhost by default. Access it through an SSH tunnel rather than exposing the port:

ssh -N -L 18789:127.0.0.1:18789 youruser@gateway-host

Then open http://localhost:18789 in your local browser. This approach means the dashboard port never touches your network, let alone the public internet. For persistent remote access without tunneling each time, OpenClaw's documentation points to Tailscale integration as the recommended path.

Persist your SSH agent's reports across sessions

Upload deployment logs, audit reports, and command outputs to a shared workspace. generous storage, no credit card, MCP-ready endpoint for your OpenClaw agent's reads and writes.

Start 14-Day Trial

The real value of running OpenClaw as an SSH session manager is not managing one Pi. It is orchestrating commands across a fleet of machines from a single conversational interface.

The Raspberry Pi blog's own article on OpenClaw describes a workflow where the author configured the agent with SSH credentials for a secondary Pi 5 and then instructed it to "SSH into the device" to manage a remote photo booth project. No manual terminal commands were needed. The author controlled file creation, web server configuration, and WiFi hotspot setup entirely through natural language prompts like "change the font to..." and "centre the text..."

OpenClaw's session tools support this pattern at scale. The sessions_spawn tool creates isolated sub-agent sessions for background tasks across hosts. A parent agent can spawn a sub-agent that connects to a staging server, runs a deployment script, and reports back, while simultaneously handling a different task on another host. The sessions_send tool enables cross-session messaging, so results from one host can trigger actions on another.

Practical Multi-Host Patterns

Consider a home lab with three Raspberry Pis: one running a media server, one handling network monitoring, and the gateway Pi running OpenClaw. Instead of opening three SSH sessions and context-switching between terminals, you tell the agent:

• "Update all packages on the media server and monitoring Pi"
• "Check if the Plex database needs a vacuum on the media server"
• "Show me the last hour of bandwidth logs from the monitoring Pi"

The agent handles SSH key authentication, connects to each host, runs the appropriate commands, and returns a summary. If a command fails, the agent includes the error output and can suggest fixes.

For teams managing cloud infrastructure alongside home lab hardware, the same OpenClaw gateway can reach cloud VMs over SSH. The orchestration layer does not care whether the target is a Pi on your desk or an EC2 instance across the country. The session management, retry logic, and result aggregation work identically.

An always-on device that holds SSH keys to other machines is a high-value target. The 135,000 exposed OpenClaw instances from the February 2026 scan illustrate what happens when operators skip hardening.

Firewall Configuration Install UFW and lock the Pi down to SSH traffic only:

sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow ssh
sudo ufw enable

Do not open port 8080 (OpenClaw's default) to the network. The SSH tunnel approach described earlier keeps the dashboard accessible without exposing it.

SSH Key Management

Store SSH keys for remote hosts in the agent's configuration rather than in plaintext files scattered across the filesystem. OpenClaw's credential management lets you rotate keys without updating scripts on every target host. When a key is compromised, you update it in one place and the agent uses the new key for all subsequent connections.

Use separate SSH key pairs for each remote host. If one target is compromised, the attacker does not gain access to every other machine the agent manages. This is more work upfront but dramatically reduces blast radius.

Network Isolation Alternatives

Local network SSH works for home labs, but reaching machines outside your network requires a secure tunnel. The options, ordered by operational simplicity:

• Tailscale or ZeroTier: mesh VPN that creates a private network between your Pi and all your devices. No port forwarding, installs with one command on each device. OpenClaw's documentation explicitly recommends Tailscale for always-on remote access.
• WireGuard: lighter weight than a mesh VPN if you only need point-to-point tunnels. Requires manual key exchange and endpoint configuration.
• Cloudflare Tunnel: creates a secure tunnel from your Pi to Cloudflare's edge. Best for exposing a web interface to specific users without a VPN.

Avoid exposing SSH directly to the public internet, even with key-based authentication. Automated scanners hit every reachable SSH port within hours. A VPN or tunnel layer means attackers cannot even reach the SSH daemon to attempt authentication.

An SSH session manager generates artifacts: command outputs, log excerpts, configuration snapshots, deployment reports. These need to go somewhere persistent and shareable, not just scroll off the terminal.

Local storage on the Pi works for short-term caching, but a single SD card failure wipes everything. S3 or similar object storage handles durability but adds API complexity and ongoing costs. Google Drive and Dropbox work for individual files but lack the workspace structure and agent-native access that orchestration workflows need.

Fastio provides a workspace layer built for this pattern. The agent uploads command outputs, deployment logs, and configuration snapshots to a shared workspace. Humans access the same workspace through a browser. When the agent finishes a multi-host deployment, it can organize the results into a folder structure, tag files with metadata, and notify a team member that the report is ready.

The practical workflow: your OpenClaw agent SSHs into three servers, runs a security audit, and collects the outputs. Instead of copying terminal output into a shared document, the agent writes structured reports to a Fastio workspace where your team can review them with full version history and audit trails. Intelligence Mode auto-indexes uploaded files, so a colleague can later ask "what were the findings from last Tuesday's audit?" and get answers with citations from the original reports.

The free tier includes 50 GB of storage, included credits per month, and 5 workspaces with no credit card required. For a home lab SSH management setup, that is more than enough storage for years of agent-generated reports. The Fastio MCP server provides the API surface for agents to read, write, search, and share files programmatically.