I manage a small fleet of Linux servers and got tired of the options:
Ansible is great but not a dashboard. Grafana + Prometheus is powerful
but heavy. Checkmk and Zabbix are overkill for a handful of machines.
So I built my own.

What is RemotePower?

RemotePower is a self-hosted control plane for Linux servers. One small
Python agent per host, one nginx + CGI server, flat JSON storage. No
database, no framework, no pip dependencies — pure Python stdlib.

The agent heartbeats every 60 seconds. The dashboard auto-refreshes.
Everything just works.

What it does

• Remote command execution — run commands, reboot, shutdown, Wake-on-LAN. Batch across devices. Cron scheduling. Command library and allowlist. Browser SSH via xterm.js.
• CVE scanning — OSV.dev backed, real CVSS v3.1 scoring, per-CVE ignore list
• Patch management — pending updates across the fleet, one-click upgrade, update history, patch alerts via webhook
• Configuration drift detection — hash critical files, baseline diffing, drift_detected webhook
• Proxmox VE integration — manage QEMU VMs and LXC containers, create and rollback snapshots, no SDK needed
• Container awareness — Docker, Podman, Kubernetes
• Custom monitoring scripts — write any bash check server-side, assign it to devices, get fleet-wide pass/fail every 5 minutes. Exit 0 = OK, anything else = FAIL. No SSH needed.
• Monitoring and alerts — ping, TCP, HTTP probes, TLS/DNS expiry, 17 webhook event types (Discord, Slack, ntfy, Gotify)
• AI assistant — optional LLM integration (Ollama, Anthropic, OpenAI). Triage CVEs, prioritise patches, generate monitoring scripts. Disabled by default, no cloud calls unless you choose one.
• MCP server — lets any MCP-capable AI client query fleet state

The architecture

[ agent (Python) ] --heartbeat--> [ nginx + CGI ] --> [ flat JSON ]

Push-based. Agents reach out — the server never needs inbound access
to your hosts. The agent is a single Python file with no dependencies
beyond the standard library.

The server is the same — pure Python CGI behind nginx. Atomic file
writes throughout. The entire thing runs on a Raspberry Pi.

Why no database?

For a small-to-medium fleet, a database is overhead without benefit.
Flat JSON files are:

• Easy to back up (one file, one command)
• Easy to inspect (cat devices.json)
• Easy to version control
• Fast enough for hundreds of devices

The backup export is a single ZIP. Restore is extracting it.

Why no pip dependencies?

Every dependency is a supply chain risk, a version conflict waiting
to happen, and something that breaks on the next distro upgrade.
Python's stdlib covers everything RemotePower needs: HTTP, JSON,
cryptography (hmac, hashlib), subprocess, threading, logging.

The agent deploys as a single file copy. No virtualenv, no pip install,
no Docker required.

Custom monitoring scripts

The newest feature and probably the most useful for day-to-day ops.

You write a bash script on the server — anything you want. Check if
nginx is responding, verify a backup file is fresh, test a database
port. Assign it to any set of devices. The agent runs it every 5
minutes and reports back.

#!/bin/bash
curl -sf --max-time 10 http://localhost/ > /dev/null
echo "HTTP OK"

Exit 0 = OK. Anything else = FAIL. Edge-triggered webhooks fire on
status changes — once when it breaks, once when it recovers. No alert
fatigue.

The UI has an AI generate button — describe the check in plain English,
get a bash script back, review it, save it.

Try the demo

https://demoremote.tvipper.com

Username: demo / Password: demo

Get it

https://github.com/tyxak/remotepower

Clone, point nginx at server/, enrol a host:

git clone https://github.com/tyxak/remotepower
./client/remotepower-agent enroll

Happy to answer questions about the architecture, the no-dependency
approach, or any of the features. And if you self-host your own
servers, I'd love to know what you'd want to see next.