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

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.

What I Was Doing Every Day (That I Don't Do Anymore)

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.

The Hardware

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.

What "AI Agent" Actually Means Here

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:

1. Scheduler (cron) — triggers tasks at intervals
2. Perception layer — scripts that fetch data (email, Fiverr, weather, calendar)
3. Reasoning layer — local LLM decides if something is worth alerting about
4. Action layer — sends me a Telegram message

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

The Fiverr Inbox Monitor (My Favorite Example)

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:

1. Opens a headless browser session every hour
2. Reads new messages
3. Runs each through a local LLM with this prompt:

   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.

1. If legitimate → instant Telegram alert with message preview
2. If scam → logged silently, no alert

Results after 3 months:

• 100% scam detection rate (verified manually afterward)
• 0 false positives
• ~10 hours/month saved
• I reply to real customers faster because I'm not wading through garbage

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

Why I Didn't Use the Cloud

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

Cost math:

• Local Qwen 3.5 9B: $0 per query, ~2 seconds response
• GPT-4o-mini: $0.00015 per 1K tokens
• 20 queries/day × 30 days × 500 tokens = ~$4.50/month

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.

What Broke (And What I Fixed)

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.

The Code (The Interesting Parts)

Core Orchestrator (simplified)

#!/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()

LLM Decision Layer

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

Notification Script

#!/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

What I Didn't Automate (And Won't)

The agent is informational, not autonomous.

I don't let it:

• Reply to emails or Fiverr messages (too risky — one bad response destroys trust)
• Make calendar changes (I'll review and confirm)
• Access financial accounts or make transactions
• Post on social media (I've seen automated tweets go very wrong)

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.

Three Months In: The Real Impact

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

What I did with the time:

• Built a Garmin watch face with live crypto charts (side project)
• Started GPU rental as passive income (another side project)
• Actually took a weekend off without checking email every hour

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.

Should You Build This?

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
→ Follow CelebiBots on Telegram