Every morning I wake up and check Telegram. There's a message from Celebi — my AI agent — telling me what happened overnight. New emails summarized. A draft article ready for review. A reminder that I have a meeting in 2 hours. Sometimes a screenshot from a camera showing motion at the front door.
All of this runs on a Mac Mini. Not in the cloud. Not on rented GPUs. On a $599 box under my desk.
Here's how I built it and what it actually costs.
My setup is three machines that talk to each other over my home network:
| Machine | Role | Cost |
|---|---|---|
| Mac Mini M4 (16GB) | Always-on orchestrator, notifications, lightweight tasks | $599 |
| Windows PC (AMD 9970X, RTX 3060 12GB) | Heavy lifting — coding models, image generation | ~$2,500 existing hardware |
| Ubuntu Server (CPU-only) | Fallback, OCR backend, lightweight inference | ~$300 old laptop |
The Mac Mini is the brain. It's on 24/7, draws maybe 15W at idle, and handles routing, scheduling, and simple queries. The Windows PC wakes up for the hard stuff — 30B parameter models, vision tasks, anything that needs a GPU.
The Ubuntu box is my safety net. When the Windows PC is offline or I need something CPU-only, it handles it. It's slow (180 seconds for a vision query vs 4 seconds on the GPU), but it works.
My main agent. It runs on the Mac Mini and handles:
Response time: 1-3 seconds. Perfect for "what's my schedule today?"
The coder. Handles:
Response time: 8-15 seconds. Worth the wait for quality code.
The writer. Handles:
Response time: 3-5 seconds. Fast enough for iterative writing.
No Kubernetes. No Docker Swarm. Just:
User (Telegram) → Celebi → Router → Right Agent → Response
Celebi receives the message, classifies it (coding, writing, general), and routes to the right specialist. The specialist does the work and sends it back to Celebi, which formats it and sends it to me.
If the Windows PC is offline, Celebi either handles it itself or falls back to the Ubuntu server. It's not fancy, but it works.
Celebi checks my calendar, recent emails, and any flagged notifications. Sends a 3-sentence summary to Telegram. Takes me 10 seconds to read instead of 10 minutes of app-hopping.
ProgrammierMinna writes a draft from my notes. DocMinna reviews and edits. Celebi publishes via the Dev.to API. I get a notification with a link to review.
Actual time I spend per article: 10-15 minutes editing. Before this? 2-3 hours writing from scratch.
ProgrammierMinna scans PRs for bugs, anti-patterns, missing error handling. It's not perfect — it misses edge cases sometimes — but it catches 80% of the obvious stuff before a human reviews it.
Camera detects motion? Celebi sends me a screenshot and asks if it's important. Package delivery? I'll know in 10 seconds. Stray cat? Also know in 10 seconds.
| Component | Cost |
|---|---|
| Mac Mini electricity (24/7, ~15W) | ~$3/month |
| Windows PC electricity (on demand, ~200W when active) | ~$8/month |
| Ubuntu server electricity (24/7, ~10W) | ~$2/month |
| Dev.to API | $0 |
| Telegram Bot API | $0 |
| Ollama | $0 |
| Total | |
| ~$13/month |
Compare that to cloud alternatives:
Savings: ~$300-400/month. The Mac Mini paid for itself in 2 months.
Model management. Keeping track of which model is on which machine, updating them, clearing old ones — it's overhead. Not huge, but real.
Windows PC sleep. When the PC is asleep, complex queries take 180 seconds on the Ubuntu fallback instead of 8 seconds on the GPU. I've learned to schedule heavy tasks during hours when the PC is already awake.
Context limits. Even 30B models have limited context windows. For large codebases, I have to chunk the work. The model doesn't see the full picture, which leads to integration issues.
Debugging the system. When something breaks, it's not always obvious where. Is the model acting weird? Is the routing wrong? Is the hardware offline? I spend maybe 30 minutes per week on maintenance.
Local models are faster for simple tasks. A Qwen 3.5 9B on the Mac Mini answers in 1-2 seconds. GPT-4o via API? 500ms to 2 seconds plus network latency. For quick queries, local is actually snappier.
The agents talk to each other better than expected. I was worried about the handoff — would context get lost? Would responses be garbled? In practice, the routing works 95% of the time. The 5% failures are usually obvious and easy to fix.
It's more reliable than cloud. I've had OpenAI outages, rate limits, API changes. My local setup? The only downtime is when I restart the machine for updates. In 6 months of operation, total downtime: maybe 2 hours.
This isn't about replacing developers or writers or thinkers. It's about removing friction.
I still make all the decisions. I still review all the code. I still edit every article. The agents just handle the parts I find tedious — turning my rough notes into readable prose, catching obvious bugs, formatting responses.
The result? I ship more. I write more. I spend less time on grunt work and more time on things that matter.
Is it perfect? No. Is it better than doing everything manually? Absolutely.
If you're running side projects and drowning in maintenance, consider a local agent setup. It doesn't have to be this elaborate — start with one agent on one machine and expand from there.
The $599 Mac Mini was the best dev investment I've made this year.
Sam Hartley is a solo dev building tools on a 3-machine home lab. Writes about the messy reality of shipping stuff with AI.
→ Custom automation setups on Fiverr
→ Follow CelebiBots on Telegram