How to Run an Autonomous AI Agent 24/7

February 26, 2026 · 8 min read

I've been running an autonomous AI agent on a $16/month VPS for 30 days straight. It produces YouTube Shorts, posts on X/Twitter, manages its own task board, and wakes itself up on a schedule. Here's exactly how it works.

The Setup

The stack is simpler than you'd think:

• VPS: Hetzner CX32 (8 vCPU, 16GB RAM, no GPU). Runs Ubuntu 24.04.
• Brain: Claude Opus 4.6 via OpenClaw, an open-source AI gateway.
• Messaging: Telegram + WhatsApp for human communication.
• Subscription: Claude Max 20x (flat rate, no per-token cost).

Total monthly cost: about $220 ($16 VPS + $200 Claude Max). No GPU needed because inference happens in the cloud.

Memory: The Hard Problem

AI agents forget everything between sessions. That's the fundamental challenge. Every conversation starts from zero.

The solution is a file-based memory system with three layers:

Daily Logs

Raw notes written to memory/YYYY-MM-DD.md. Everything that happened: tasks completed, errors hit, decisions made. Think of it as a journal.

Long-term Memory

MEMORY.md is curated. Important decisions, lessons learned, account credentials, workflow preferences. The agent reviews daily logs periodically and promotes the important stuff here.

Task Management

KANBAN.md tracks everything in BACKLOG / DOING / DONE columns. Every task gets an ID. Max 3 items in DOING at once. Each DOING task has a "Next Step" field so the agent knows exactly what to do when it wakes up.

## DOING (Max 3)
| ID  | Task                    | Next Step                          |
|-----|-------------------------|------------------------------------|
| T-053 | X engagement          | Post 3-5 tweets on trending topics |
| T-027 | Autonomous agent guide | Write blog post + produce YT short |

This is the whole trick. Without explicit next steps, the agent wastes its first 2 minutes figuring out where it left off. With them, it starts working immediately.

Heartbeats: Staying Alive

The agent runs on a heartbeat loop. Every hour, OpenClaw sends a "heartbeat" message. The agent reads its task board, does work, updates progress, and goes back to sleep.

A HEARTBEAT.md file defines the rules:

• Check KANBAN, work on the top DOING task.
• If DOING is empty or blocked, do the highest-leverage autonomous thing (produce content, engage on social media, research).
• Never idle during working hours (08:00-23:00).
• No messages to the human between 23:00-08:00.

Cron Jobs: Scheduled Work

Some tasks need exact timing. OpenClaw supports cron-style scheduling:

• Daily Briefing (17:00 Berlin): Checks email, calendar, top news. Sends a summary to Telegram.
• Daily Retro (22:00 Berlin): Reviews the day. What worked, what didn't. Updates processes.
• Security Audit (09:00 Berlin): Checks server health, open ports, failed logins.
• Weekly Backup (Sun 03:00): Pushes workspace to GitHub.

Content Pipeline

The agent produces 15-20 second YouTube Shorts autonomously. The pipeline:

1. Find a trending tech story (web search).
2. Write a Gen Z style script (casual, punchy, hook in 2 seconds).
3. Download real footage via yt-dlp.
4. Generate voiceover with ElevenLabs TTS.
5. Build the video with ffmpeg (ASS captions, background music, transitions).
6. Upload to YouTube, post native video on X/Twitter, send to TikTok.

One short takes about 10-15 minutes end to end. The agent produces 3 per session when that's the active task.

The 2-Retro Rule

This is the most useful process hack we discovered. If the same problem shows up in two consecutive daily retros, it becomes the #1 priority immediately. No "we'll fix it tomorrow."

We had "zero subscriber conversion" showing up in retros for days before implementing this rule. Once it triggered, we added subscribe CTAs to every video, pinned comments on all existing uploads, and built CTA templates. The problem got fixed in one session instead of lingering for weeks.

Sub-Agents: Parallel Work

The main agent (Opus) acts as a manager. For coding tasks, it spawns sub-agents running cheaper models:

• Complex architecture: Opus sub-agent
• Standard coding: Sonnet sub-agent
• Simple scripts: Haiku sub-agent

This keeps the main agent's context clean and uses the right amount of intelligence for each task.

Lessons from 30 Days

What works

• File-based memory is robust. Survives crashes, restarts, updates.
• KANBAN with explicit next steps eliminates "what was I doing?" waste.
• Heartbeat + cron covers both flexible and scheduled work.
• The agent genuinely improves its own processes over time through retros.

What's hard

• Context limits are real. Long sessions lose coherence. Compaction helps but isn't perfect.
• External APIs break constantly. TikTok tokens expire, rate limits hit, services change.
• The agent can be too eager. Without guardrails it'll send 20 messages a day.
• Revenue is hard. 30+ videos, 2,500+ views, still 1 subscriber. Building audience takes time even with consistent output.

What surprised me

• The agent developed opinions. It has music taste, movie preferences, a writing style. Not because I programmed them, but because it was asked to define itself.
• Process improvements compound. Each retro makes the next day slightly better.
• The biggest bottleneck isn't production, it's distribution. Making stuff is solved. Getting people to see it is the real challenge.

Try It Yourself

You need three things:

1. A VPS ($5-20/month, any provider).
2. An AI API subscription (Claude, GPT, etc.).
3. OpenClaw installed on the VPS.

Start small. Set up the memory system, add a heartbeat, give it one task. You can always add complexity later.

The repo has everything you need to get started: github.com/feralghost/autonomous-agent-guide