Slow and Steady: An Agent That Runs My Apify Side Business While I Sleep

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

I run 13 public web-scraping Actors on the Apify Store as a side business. Keeping up with the platform — blog announcements, Store trends, pricing-compliance deadlines, new monetization features — is exactly the kind of chore I kept putting off. So I built Phoenix: an autonomous agent on a cron schedule that does the whole daily platform watch for me and delivers an 8-line report while I'm still asleep.

Every morning, on its own, it:

• scans the Apify blog RSS for anything published in the last 48 hours
• pulls the Apify Store top-10 to spot demand trends
• audits my Actors' pricing configuration (pay-per-event migration compliance)
• checks my saved tasks against the Store's newest SEO surface, published task examples
• executes whatever is deliverable end-to-end — not just reading, but doing: configs, fixes, submissions — then logs done-vs-read in a dated markdown file
• watches dev.to challenges with cash prizes and drafts submissions (yes, the research for this very post was done that way)

The sloth philosophy, applied: conserve energy, let the machine do the rounds.

Demo

Real, unedited output from this morning's run (October 24, 2026):

• Blog scan: Apify shipped bulk task-example publishing via API on Oct 22 — their case study claims organic traffic to an Actor page doubled after publishing examples.
• Audit: I have 11 saved tasks across my Actors and zero published task examples. Gap identified, publish payloads prepared.
• Action attempted: the agent tried the publish API call… and got 403 platform-feature-disabled. Instead of silently failing, it traced the cause: my account had burned through its $5 monthly hard limit — 0.58 GB of residential proxy (~$4.60) consumed by one overeager scraper run. It flagged it for my review, with the numbers.

I learned about a new Store SEO feature and a billing problem before my first coffee, with zero clicks.

Code

The harness is Hermes Agent — an open-source agent runtime by Nous Research (docs). The daily watch is a cron job that hands the agent a task file; the agent loops: scan → reason → act → log. The platform knowledge lives in plain-markdown "skill" files, and the actual checks are small scripts the agent writes and runs itself, like this abridged one from today:

import json, urllib.request

def getj(url):
    req = urllib.request.Request(url, headers={"User-Agent": "phoenix-cron"})
    with urllib.request.urlopen(req, timeout=30) as r:
        return json.load(r)

# Which of my Actors are still PPE-compliant?
acts = getj(f"https://api.apify.com/v2/acts?my=1&token={TOKEN}&limit=50")
for it in acts["data"]["items"]:
    det = getj(f"https://api.apify.com/v2/acts/{it['id']}?token={TOKEN}")["data"]
    if det.get("isPublic"):
        print(det["name"], "->", (det.get("pricingInfos") or [{}])[0].get("pricingModel"))

No framework lock-in: the harness calls shell, Python, and a real browser over CDP. That's the whole stack.

How I Built It

• Orchestration: Hermes Agent, open-source. The agent reads its instructions, picks tools, writes its own helper scripts, and iterates until the task verifies — a real agent loop, not a Zapier-style flow.
• Scheduling: a boring, glorious cron line. Slow and steady, every day at the same hour.
• Knowledge: markdown skill files (actor doctrine, preflight checks, the publishing API contract). When Apify changed task-example limits from 50 to 10 per Actor, I edited a text file — not a support ticket.
• Model-agnostic: the harness doesn't care which LLM drives it. You can point the same setup at an open-weight model and the loop still works; the automation survives the swap.

Why Does Open Innovation Matter?

Three concrete things a closed automation platform wouldn't give me:

1. My credentials never leave my machine. The agent touches Gmail, Apify, and Stripe tokens daily. They live in local files on my own server in Luxembourg — not in a vendor's cloud, not in someone's "workspace".
2. Everything is inspectable and forkable. Skills are text. Scripts are text. Logs are text. When something breaks at 6 AM, I can diff it, fix it, and the fix is permanent — not a black-box retry policy I can't see.
3. No platform risk on the orchestration layer. Closed assistants lock you into their model, their pricing, their roadmap. An open harness means my morning routine keeps working even if I switch models tomorrow. Open weights crossing the quality bar is a when, not an if — and I'm already wired for it.

The Lazy Payoff

About 45 minutes of daily platform-watch compressed into reading 8 lines. This week alone the agent prepared task-example configs for the Store's new SEO surface, verified pay-per-event pricing on all 13 public Actors ahead of the migration deadline, and caught a hard-limit billing issue — all while I did literally nothing.

Sloths had it figured out. Build the thing once, let it do the rounds forever.