# I Replaced 2.5 Hours of Daily Busywork with a $0 AI Agent Setup

> Source: <https://dev.to/samhartley_dev/i-replaced-25-hours-of-daily-busywork-with-a-0-ai-agent-setup-13ad>
> Published: 2026-06-25 08:05:09+00:00

Three months ago I was spending almost three hours a day on tasks a script could do. Email triage, inbox checks, calendar reminders, weather lookups, market data refreshes. Nothing creative. Nothing that needed my brain. Just... mechanical.

I didn't want another SaaS subscription. I didn't want to glue together Zapier and Notion and hope it worked. I wanted something I owned, running on hardware I already had, costing me nothing after setup.

So I built it. And it actually works.

Here's what I automated, how I built it, and what broke along the way.

| Task | Before | After |
|---|---|---|
| Check 3 email accounts for urgent stuff | ~25 min | Agent alerts me only when something matters |
| Fiverr inbox — new inquiries + scams | ~20 min | Hourly scan, instant Telegram notification |
| Calendar — what's happening today? | ~10 min | Morning summary at 9 AM, prep alerts 30 min before |
| Weather check before leaving | ~5 min | Agent tells me if I need an umbrella |
| Market data for my watch face | ~15 min | Live data every 15 min, zero interaction |
| Code review on my own repos | ~45 min | Automated PR summaries in 12 seconds |

**Total: ~2 hours 40 minutes → ~10 minutes of actual attention**

The 10 minutes is me reading alerts and deciding what to do. The agent doesn't make decisions. It surfaces information.

Everything runs on a Mac Mini M4 I already owned. No cloud VMs, no rented GPUs for this part.

```
Mac Mini M4 (always on, ~8W idle)
├── Ollama (local LLM)
│   ├── qwen3.5:9b — general reasoning
│   └── qwen3-coder:30b — code analysis (via network GPU)
├── Python scripts + cron jobs
├── Telegram Bot API — notifications
└── Background services (Garmin updater, health checks)
```

Monthly cost for the AI layer: **$0**. The Mac Mini was already running 24/7 for other projects.

Let's be honest: "AI agent" is an overused term. What I built is a collection of Python scripts that use a local LLM for the parts that need understanding, and plain old regex/cron for everything else.

**The agent isn't one thing. It's a system:**

That's it. No autonomous web browsing. No decision-making without my input. Just: see → understand → tell me.

I sell automation services on Fiverr. Checking the inbox was eating 20 minutes a day. Worse: half the messages were scams ("contact me on WhatsApp for big project").

My agent now:

```
   Is this a legitimate business inquiry or a scam?
   Scam indicators: external contact requests, generic greeting + immediate project offer,
   poor grammar with urgent tone, requests to communicate off-platform.

   Message: {message_text}

   Respond: LEGITIMATE or SCAM with one-sentence reasoning.
```

**Results after 3 months:**

The LLM handles the nuance. Regex would miss edge cases. A human would get bored and slip up.

I have API keys for OpenAI, Anthropic, and Google. I use them for complex reasoning tasks. But for automation?

**Cost math:**

That's not nothing for a side project. But more importantly: **latency**. Local inference is faster for simple tasks, doesn't need internet, and doesn't send my emails/Fiverr messages to a third party.

The cloud is my fallback for tasks the 9B model can't handle. Maybe 5% of queries.

**Week 1:** The Fiverr login session expired after 48 hours. I was running headless Chrome with saved cookies. Fiverr's session management is aggressive.

**Fix:** Switched to Safari with AppleScript automation. No session issues since — Apple's keychain handles authentication transparently.

**Week 2:** Alert fatigue. I set the agent to notify on *every* email. Bad idea.

**Fix:** Two-tier system. "Urgent" alerts (from known contacts, specific keywords) → instant notification. "Everything else" → digest at 9 AM and 6 PM. Unsubscribe-style filtering.

**Week 3:** The weather API I was using (free tier) rate-limited me.

**Fix:** Added a fallback chain. Primary → wttr.in → OpenWeatherMap (rarely hit). The agent doesn't care which source works.

**Month 2:** LLM started hallucinating calendar events that didn't exist.

**Fix:** Added validation layer. LLM extracts event details → script queries the actual calendar API → confirms before alerting. LLM suggests, system verifies.

``` bash
#!/usr/bin/env python3
"""Main agent loop — runs every hour via cron"""

import schedule
import time
from agents import email_agent, fiverr_agent, calendar_agent, weather_agent
from notifier import telegram_alert

def run_all_checks():
    """Run all agents and collect alerts"""
    alerts = []

    # Each agent returns (alert_text, priority) or None
    alerts.append(email_agent.check())
    alerts.append(fiverr_agent.check())
    alerts.append(calendar_agent.check())
    alerts.append(weather_agent.check())

    # Send urgent immediately, batch low-priority
    urgent = [a for a in alerts if a and a[1] == "urgent"]
    batch = [a for a in alerts if a and a[1] == "normal"]

    for alert in urgent:
        telegram_alert(alert[0], priority="high")

    if batch:
        digest = "📊 Agent Digest\n\n" + "\n\n".join([a[0] for a in batch])
        telegram_alert(digest, priority="normal")

# Cron runs this script hourly
if __name__ == "__main__":
    run_all_checks()
php
import ollama

def should_alert(email_data: dict) -> tuple[bool, str]:
    """Use local LLM to decide if an email warrants immediate notification"""

    prompt = f"""You are an email triage assistant. Analyze this email:

    From: {email_data['sender']}
    Subject: {email_data['subject']}
    Preview: {email_data['preview'][:200]}

    Rules:
    - ALERT if: from known contact, contains "urgent/meeting/action required",
      payment-related, or from a service I actively use
    - SILENT if: newsletter, promotional, automated notification,
      no action needed

    Respond ONLY with: ALERT: [reason] or SILENT: [reason]"""

    response = ollama.chat(
        model="qwen3.5:9b",
        messages=[{"role": "user", "content": prompt}]
    )

    result = response['message']['content'].strip()
    is_alert = result.startswith("ALERT")
    reason = result.split(": ", 1)[1] if ": " in result else "No reason given"

    return is_alert, reason
bash
#!/bin/bash
# notify.sh — called by any agent

BOT_TOKEN="..."
CHAT_ID="..."
MESSAGE="$1"
PRIORITY="${2:-normal}"

curl -s -X POST "https://api.telegram.org/bot${BOT_TOKEN}/sendMessage" \
  -d chat_id="${CHAT_ID}" \
  -d text="${MESSAGE}" \
  -d parse_mode="HTML" > /dev/null
```

The agent is *informational*, not *autonomous*.

**I don't let it:**

**The rule:** The agent tells me what I need to know. I decide what to do. This isn't laziness — it's risk management. AI is excellent at detection, mediocre at judgment.

**Time saved:** ~2.5 hours/day = ~75 hours/month. That's almost two full work weeks.

**What I did with the time:**

**Unexpected benefit:** I make better decisions because I'm not decision-fatigued. When you've already spent mental energy on inbox triage, your judgment on actual work suffers.

**Cost:** $0 for AI, ~12 hours initial setup, ~30 minutes/week maintenance.

If you're spending >1 hour/day on mechanical tasks: probably yes.

If you're expecting a magic "AI agent" that runs your life: no. This is scripting with a smart layer on top. The LLM handles ambiguity. Everything else is just... code.

**Start with one task.** Get it reliable. Add the next. I began with just email triage. Two weeks later I added Fiverr. Then calendar. Then weather. Each one took an evening.

The compound effect is what matters.

*I write about building automation systems that actually work — local AI, self-hosted tools, and side projects that make money while you sleep.*

→ [Check out my automation work on Fiverr](http://www.fiverr.com/s/XLyg)

→ [Follow CelebiBots on Telegram](https://t.me/celebibot_en)