DEV Community

ULNIT
ULNIT

Posted on

How I Turned a Raspberry Pi into a 24/7 AI Automation Hub

#raspberrypi #automation #python #tutorial

From Tinker Toy to Production-Grade Automation Hub

I still remember the day I unboxed my first Raspberry Pi. It was a Pi 4 with 4GB of RAM, and like many developers, my first thought was: This is neat, but what can I actually do with it?

Fast forward two years, and that same little board is now the backbone of my entire automation infrastructure—running AI agents, scheduling cron jobs, monitoring APIs, and even handling lightweight bug bounty reconnaissance. In this post, I will walk you through exactly how I built it, what I learned along the way, and how you can do the same.

The Problem: Cloud Costs Add Up Fast

When I started experimenting with AI agents and automation scripts, I defaulted to AWS and DigitalOcean. It was easy, but my monthly bill crept past $80 before I even had anything running in production. For a solo developer building side projects, that is unsustainable.

I needed something cheaper. Something that could run 24/7 without breaking the bank.

Enter the Raspberry Pi.

The Setup: What You Will Need

Here is my current stack:

  • Raspberry Pi 4 (4GB) – the heart of the operation
  • 128GB SanDisk Ultra microSD – plenty of room for logs and datasets
  • PoE HAT – clean power delivery, no extra cables
  • Docker + Docker Compose – containerize everything
  • Python 3.11 + cron – the automation engine
  • Ngrok – expose local services when needed

Total one-time cost: ~$120. Monthly operating cost: ~$0 (besides electricity).

What I Am Actually Running on It

1. AI Agent Orchestration

I run multiple Python-based AI agents that handle tasks like:

  • Content generation and scheduling
  • API monitoring and alerting
  • Data scraping and transformation

Each agent is a Docker container managed by a simple orchestration script. When one crashes, it auto-restarts. When logs get too big, they rotate automatically.

2. Bug Bounty Reconnaissance

This is where things get interesting. I have cron jobs that run nightly to:

  • Enumerate subdomains for target programs
  • Check for newly exposed ports and services
  • Monitor certificate transparency logs
  • Diff results against previous runs and alert on changes

The Pi handles this beautifully. It is not fast, but it does not need to be—it is consistent, reliable, and costs nothing to leave running.

The Automation Stack in Detail

Here is a simplified version of my daily recon cron job:

#!/bin/bash
# /home/pi/cron/daily-recon.sh

TARGETS="targets.txt"
OUTPUT="/home/pi/recon/$(date +%Y%m%d)"
mkdir -p $OUTPUT

for domain in $(cat $TARGETS); do
    subfinder -d $domain -o $OUTPUT/${domain}_subs.txt
    httpx -l $OUTPUT/${domain}_subs.txt -o $OUTPUT/${domain}_live.txt
done

# Diff against yesterday and alert if new findings
python3 /home/pi/scripts/diff_and_alert.py $OUTPUT
Enter fullscreen mode Exit fullscreen mode

This runs every night at 2 AM. I wake up to a Slack notification if anything interesting changed.

Lessons Learned (The Hard Way)

SD Cards Die

My first SD card failed after 8 months of heavy logging. Now I use a high-endurance card and mount /var/log to a USB drive. Backups are automated to a NAS weekly.

Python Dependencies Are Fragile

I used to install everything globally. Do not do that. Now every project has its own virtual environment, and I pin dependencies with pip freeze > requirements.txt.

Monitoring Matters

If you are not watching your Pi, you will not know when things break. I use a simple health check script that pings a monitoring service every 5 minutes. If it misses two pings in a row, I get an alert.

The Products That Made This Possible

Building this setup from scratch took months of trial and error. If you want to skip the painful parts and get straight to a working automation lab, I have packaged everything I learned into two products:

  1. AI Agent Toolkit – A complete Python-based framework for building and deploying AI agents on low-resource devices like the Raspberry Pi. Includes pre-built agent templates, Docker configs, and deployment scripts. At just $9, it is the fastest way to get agents running on your Pi.

  2. Bug Bounty Automation Kit – My full reconnaissance automation suite. Subdomain enumeration, port scanning, change detection, and alerting—all pre-configured and ready to run on a Pi. For $15, it saves you weeks of scripting and debugging.

Both are designed specifically for self-hosted, low-cost environments like the Raspberry Pi. No cloud required.

What is Next

I am currently experimenting with running small language models directly on the Pi using llama.cpp. A 3B parameter model runs at about 3 tokens/second—not fast, but usable for simple classification and summarization tasks.

My goal is a fully autonomous Pi that can:

  • Monitor my projects
  • Generate simple reports
  • Alert me to anomalies
  • All without ever sending data to the cloud

We are not quite there yet, but every month the Pi gets a little more capable.

Your Turn

If you have a Raspberry Pi sitting in a drawer, pull it out. Install Docker. Write a simple Python script. Set up a cron job. You will be amazed what that little board can do.

And if you want to skip the months of trial and error, grab the AI Agent Toolkit or the Bug Bounty Automation Kit and get started today.

What is your Raspberry Pi automation setup? Drop a comment below—I am always looking for new ideas.

Top comments (0)