If you are running an M1 MacBook Pro with 16GB of RAM, you are in a unique position. You don’t have dedicated VRAM like a PC graphics card. But, Instead, you have Apple’s Unified Memory Architecture.
Because your CPU and GPU share the same memory pool, macOS restricts the GPU to using roughly 75% of your total physical RAM to prevent the system from crashing.
This means your “16GB Mac” actually has about 11.5GB to 12GB of usable VRAM for AI models.
You need a model small enough to fit in that 12GB window, while leaving enough leftover headroom for a decent enough context window and your daily apps.
Here is the current 2026 landscape for what runs best:
Firstly, how did we come here?
As you’re aware (are you?), I have a couple of apps
We’ve all been there: waking up to an inbox flooded with newsletters, automated alerts, and the occasional critically important message hidden in the noise.
Basically, I wanted a solution that would summarize my inbound emails, remove distractions and ping me with a digest.
But more importantly, I wanted it to be private, local, and completely hands-off.
Instead of relying on a third-party cloud service to read my emails, I decided to leverage my Apple Silicon Mac to build an automated, background AI agent.
The basic goal?
Monitor, process, and summarize inbound emails (that I get at support@aibucket.org), then dispatch a clean digest directly to my Telegram every 6 hours: without any human intervention.
But imagine: this itself took me days to figure out where I had to experiment with so many models as some was not able to summarize well, some would give me incorrect action items while some just hallucinated into calling a spam email important.
Until I found the sweet spot:
Qwen 3.5 9b
Here is how I built a resilient, deterministic automation loop using Hermes, Qwen 3.5, and a bit of defensive Python.
The Architecture & Tech Stack
To make this work seamlessly in the background, I needed an architecture that was lightweight enough to run continuously but powerful enough to handle natural language processing.
- Hardware: Apple Silicon Mac (M-series) — the unified memory is perfect for local LLMs.
- Local Intelligence: Ollama running Qwen 3.5 9B. This serves as the reasoning engine to process and summarize email context locally.
- Gateway & Scheduling: Hermes, a background agent daemon that handles cron scheduling and native messaging gateways (I have used Hermes as I know I’ll have more usecases)
- Email API: Resend API, used to fetch inbound email metadata and body content cleanly.
- Delivery Channel: Telegram (integrated natively via Hermes’ gateway).
Step-by-Step: Building the Pipeline
Step 1: Spinning Up Local Intelligence
The brain of this operation is Qwen 3.5 (9B), served locally via Ollama. Running this on Apple Silicon is incredibly efficient. It is good at above average coding, can understand what I want from email digests and can itself fix most of the issues.
Once Ollama was installed, I configured my local environment variables to allow seamless IPC/HTTP access between my background scripts and the local Qwen inference server.
This ensures the Python script can pass email strings to the model and instantly receive summaries without a hitch.
Step 2: Hardening Key Management
If you’ve ever built background automation, you know the pain of silent headless failures.
Background cron daemons do not run in your interactive shell, meaning your carefully crafted ~/.zshrc exports won't load.
To prevent the agent from crashing on boot, I isolated all credentials to a single environment file located at ~/Desktop/agent-sk/keys/keys.env.
I then configured the script's boot sequence to explicitly use absolute paths to locate and validate the Resend and Telegram API keys before attempting any network calls.
Step 3: Writing the Script (check_emails.py)
The actual logic lives in a custom Python script at ~/.hermes/scripts/check_emails.py. When writing scripts meant to run unattended for months, defensive programming isn't just a best practice, it's a requirement.
Here is how I hardened the script:
- Inbound-Only Filtering: The script explicitly filters out outbound and sent items, strictly compiling incoming messages.
- 24-Hour Lookback Window: I implemented a dynamic time-range check. This ensures that even if a 6-hour cron trigger is missed (e.g., the Mac is somehow turned off or asleep), the script maintains a complete context window and no messages fall through the cracks.
- Strict Timeout Controls: Unbounded HTTP requests are the number one reason background tasks lock up. I configured explicit 15-second execution timeouts on all
requests/httpxcalls. If the network drops, the script fails gracefully rather than hanging indefinitely. - Payload Sanitization: The script extracts the Subject, Sender, and Body, stripping out messy HTML and formatting it into clean strings for Qwen to process.
Step 4: Automating with Hermes
Instead of writing boilerplate Python code to handle cron schedules and Telegram API wrappers, I offloaded the “glue” to Hermes.
Using Hermes’ native cron capabilities, I scheduled the script to trigger every 6 hours (0 0,6,12,18 * * *)
Because Hermes has built-in messaging gateways, I simply routed the script’s output directly to the Telegram Gateway.
It takes the output generated by Qwen and pushes it to my phone instantly.
Building this project reinforced a few critical rules for local AI automation:
- Explicit Paths are Mandatory in Headless Environments: Because background cron daemons skip your interactive shell profile, relying on relative paths or standard environment variables is a trap. Explicitly loading your
.envfiles via absolute paths is essential to avoid silent startup crashes. - Defensive Networking is Non-Negotiable: Whenever an agent makes a network call, it must have an explicit timeout. A hanging HTTP request will silently kill your automation loop.
- Deterministic Logic + Agentic Intelligence = Reliability: While Qwen 3.5 provides the “magic” (summarizing and reasoning about the text), wrapping that intelligence in standard, deterministic Python execution and Hermes’ gateway creates an unbreakable, low-cost automation loop.
By combining the raw power of Apple Silicon with lightweight tools like Ollama and Hermes, we are finally at a point where personal, private, always-on AI assistants aren’t just possible , they’re practical to build in a weekend.
Notable mentions with ranks that weren’t as good as advertised for my usecase, but might be for yours:
2. Gemma 4 8B or 12B
3. Llama 4 8B
4. Qwen 3.5 4B
techaiguild.aibucket.org
In case we are meeting for the first time, come over here, it’ll be worth the roller coaster of articles that are gonna come up in the next few weeks.