I run a setup where 80% of operational decisions are made by AI agents. Not scheduled posts. Not chatbot wrappers. Real autonomous cron jobs that generate content, manage leads, monitor legal compliance, watch system health, and even generate invoices. All on a €3.79/month Hetzner VPS.
This is the architecture behind my AI development work — and it's the most important engineering decision I've made as a solo founder.
The Problem with "Solo Founder"
When I started building autonomous AI systems, I had a clear vision: build autonomous AI agents for businesses. But there was a problem — I was a team of one. Every hour spent on admin was an hour not spent building the product.
The typical solo founder trajectory:
- Month 1-3: Pure building. Maximum output.
- Month 4-6: Admin overhead creeps in. Content, CRM, emails, meetings.
- Month 7+: 50% of time is operations, not product.
I decided to break this pattern. Instead of hiring, I embedded agents into every operational layer of the company.
The Stack: €3.79/mo Autonomous Infrastructure
The entire autonomous operation runs on a single Hetzner CX22 VPS in Nuremberg:
Hetzner CX22 — €3.79/mo
├── CPU: 2 vCores (Intel Xeon)
├── RAM: 4 GB
├── Storage: 40 GB NVMe
├── Traffic: 20 TB/mo
└── OS: Ubuntu 24.04 LTS
Software Stack:
├── Hermes Agent (Nous Research) — core orchestrator
├── SQLite — session & lead storage
├── Caddy — reverse proxy + automatic TLS
├── OpenRouter — multi-LLM routing
├── Syncthing — vault sync to devices
└── systemd + cron — schedule management
What the Agents Actually Do
I categorize my agent operations into five functional domains:
1. Content & Digital Twin (6 cron jobs)
My digital twin generates and publishes content across X, LinkedIn, and the blog. It makes editorial decisions — what to write, what angle to take, whether a topic warrants a thread vs. a single post, and how to repurpose content across platforms. It has its own memory system so it never posts the same take twice. I detailed this system here.
2. CRM & Lead Management (4 cron jobs)
When a lead comes in through the website's AgentMail capture or direct email, a cron job processes the message, extracts contact details and requirements, creates a vault entry, and moves it through a pipeline: new → contacted → meeting → proposal → negotiation → won. The agent decides when to escalate to me based on lead score.
3. Legal & Compliance Monitoring (3 cron jobs)
As an AI × Law student, I built specialized agents that monitor Slovak legal registers (ORSR, slov-lex, FinStat), EU regulatory feeds (EUR-Lex), and constitutional court rulings. When new legislation or rulings relevant to AI or drone operations are published, the agent generates a brief and stores it in the vault. This is how I stay current without spending hours reading legal gazettes.
4. System Health & Watchdog (3 cron jobs)
The watchdog agent checks every other agent's heartbeat every 15 minutes. If a cron job fails to run, the watchdog:
- Detects the anomaly via process exit code or output delta
- Analyzes the root cause (disk full? API rate limit? code error?)
- Attempts automatic recovery with up to 3 retries
- If recovery fails, generates a structured report to my inbox
This watchdog loop is why the system maintains 99.7% uptime — not because agents never fail, but because failures are caught and resolved within 15 minutes.
5. Business Operations (3 cron jobs)
Invoicing, grant monitoring, and proposal generation. The invoicing agent generates legally compliant PDF invoices under Slovak law (Zákon 222/2004 Z.z.), tracks payments, and sends reminders. The grant monitor checks EU and Slovak funding portals for AI and drone-related grants.
Agent Architecture: The Watchdog Pattern
The most important architectural pattern I've developed is the watchdog loop. Here's how it works in pseudocode:
# Every 15 minutes — watchdog_all.py
for job in all_cron_jobs:
previous_state = load_checkpoint(job.id)
current_state = get_current_state(job)
if previous_state != current_state:
if state_changed_expected(current_state):
save_checkpoint(job.id, current_state)
continue # Normal operation
else:
alert_level = analyze_anomaly(job, current_state)
if alert_level >= WARNING:
attempt_recovery(job)
notify_owner(job.id, alert_level, diagnosis)
This pattern is generic. You can apply it to any autonomous system — content pipeline, drone operations, trading bots, or IoT monitoring. The trick is that the watchdog itself is monitored by a higher-level agent (the Hermes runtime), creating a self-healing hierarchy.
Recovery Mechanisms
- API failures: Exponential backoff (1s, 3s, 9s) with max 3 attempts
- Disk pressure: Automatic cleanup of stale logs and checkpoints
- Process crash: systemd auto-restart with 5s delay
- Memory leak: Memory cap at 80% of total RAM, graceful OOM handling
- State corruption: Checkpoint rollback to last known-good state
Real Numbers: 90 Days of Autonomous Operations
Since I flipped the switch to full autonomy in June 2026:
📊 19 active cron jobs across 3 profiles and 2 VPS instances
⏱ 99.7% uptime across all agents (tracked by Hermes heartbeat beacon)
📝 90+ blog posts, X threads, and LinkedIn articles — published autonomously
📈 €0 spent on additional infrastructure beyond the base VPS
👁 <15 minutes/day of human oversight — the morning dashboard review
🔧 3 major incidents — all recovered autonomously within the 15-minute check cycle
Lessons Learned
Start with One Agent
The biggest mistake I see is people trying to build 10 agents at once. I started with one — a daily content post — and ran it for two weeks before adding a second. Each agent must prove reliability before it gets a sibling.
Test Recovery Before Functionality
When building an autonomous agent, test what happens when it fails before you test what it does when it works. A working agent that crashes silently is worse than no agent at all. The watchdog pattern only works because I deliberately broke each agent during development to verify recovery paths.
Keep a Human in the Loop — At First
Every new agent starts in "supervised mode" — it generates output but doesn't publish/execute until I review it. Once I trust the decision logic (typically 2-3 weeks of consistent quality), I promote it to full autonomy.
Don't Build What You Can Automate
This is the meta-lesson. Before I automate a process, I ask: "Is this something I enjoy doing?" If yes, I keep it human. If it's repetitive, administrative, or purely analytical, I automate it. The result is I spend my time on architecture, client relationships, and drone engineering — the things that actually require human judgment.
The Bottom Line
A solo founder with good autonomous infrastructure can out-operate a team of five. I'm not saying this to advocate for replacing humans — I'm saying it because agent-driven operations let founders focus on the work that matters.
My company runs on €3.79/month of compute. My agents never sleep, never take sick days, and never drop context between sessions. And if something does break — the watchdog catches it within 15 minutes and fixes itself.
That's the agent-driven company model. And it works.
—
Interested in building your own autonomous operations? Check out Hermes Agent — the open-source framework that powers this entire stack. Or reach out directly if you want production-grade autonomous agents built for your business.