Log entry2026-11-14
← All entries
11 min read

Inbox zero on a Mac mini, with the model on my gaming PC

TechnologyAIAgentsProton MailPrivacySelf-hostingLocal LLMJevhachiflow

Unofficial project. higgs is an independent, community-built CLI. It is not affiliated with, endorsed by, or sponsored by Proton AG. "Proton" and "Proton Mail" are trademarks of Proton AG, used here only to describe interoperability.

When I wrote the higgs post, the daily run was me. I opened a terminal twice a day, started an agent, and watched it work. It worked, but it only ran when I remembered to run it, and only on whatever laptop I had open.

I wanted three things, and I had never had all three at once:

  1. An agent that is always on. It wakes on a schedule and does its job without me there.
  2. An agent that is isolated. It has its own computer and its own credentials, not mine.
  3. Inference I own. The model that reads my email runs on hardware in my house.

Now I have all three. The agent runs on a Mac mini under hachiflow, self-hosted on my home network. Every hour it wakes up and works my Proton Mail toward empty. The classification, the part that actually reads my mail, runs on my gaming PC, which serves a Jev-style decision model on the LAN.

The topology

Cloud hachiflow.com schedule · messages · report

Only the schedule and a short report cross this line. The model that reads my mail never runs here.

Home network 192.168.50.0/24 mail stays here

hachiflow machine Mac mini 192.168.50.10
runnerd
inbox-zero agent box Docker, hardened higgs CLI
IMAP :1143
HTTP :8791
Inference Gaming PC 192.168.50.20
Proton Mail Bridge IMAP :1143
Open-Jev-2B :8791 /v1/systemone
  1. Wake. hachiflow.com starts the hourly run on the Mac mini.
  2. Fetch. higgs pulls new mail from Proton Mail Bridge over IMAP.
  3. Classify. Each message goes to Open-Jev-2B, and a typed verdict comes back.
  4. Label. higgs apply-labels writes the verdicts back over IMAP.
  5. Report. A short report goes to hachiflow.com. The mail never does.
One hourly run, end to end. The LAN addresses are placeholders.

Three things run in my house:

  • The Mac mini is a hachiflow machine. It shows up in my account as an online machine I brought myself (darwin-arm64, runnerd v0.34.0). Each agent turn runs inside a hardened Docker box on it.
  • The gaming PC at 192.168.50.20 runs the inference. It serves Open-Jev-2B, an open-weight, Jev-style decision model, on port 8791. Proton Mail Bridge runs there too, so the agent has an IMAP door to the mailbox.
  • The inbox-zero agent lives in my Origin workspace on hachiflow and runs only on that Mac mini.

hachiflow.com handles the schedule, the messages I send the agent, and the short report it sends back. It does not run the model that reads my mail.

The LAN addresses in this post are stand-ins, not my real ones.

Why a decision model, and why on the gaming PC

TypeSafe introduced Jev as a "System One" model: it doesn't chat, it decides. You send it a state and a set of typed questions (pick one of these labels, yes or no, a score from one to five), and it returns probabilities and a confidence. It writes no prose. For email triage that is the right shape. I don't need a model to write an essay about an invoice. I need it to say "Finance, 0.9" and move on.

The hosted Jev runs in TypeSafe's cloud, which breaks my one rule: my mail doesn't leave my hardware. The open-source Open-Jev server implements the same /v1/systemone API, and Open-Jev-2B is a LoRA adapter plus a decision head on a 2B Qwen base model. It's small enough to run on a consumer GPU, and the GPU in my gaming PC sits idle most of the day anyway.

higgs has spoken this API since I added Jev support to higgs classify. That post has the benchmarks: on the same GPU, Open-Jev-2B scored 155 real emails about 2.6× faster than gemma4:e4b, and ranked them better (AUROC 0.87 vs 0.81), with category labels on par. Pointing higgs at the gaming PC is two environment variables:

export PM_CLASSIFY_BACKEND=jev
export PM_JEV_BASE_URL=http://192.168.50.20:8791
higgs classify INBOX --limit 200 --workers 4

Each message goes to the gaming PC, and a typed verdict comes back over the LAN. The labels, the confidence and the is_mailing_list flag land in higgs's local state, and higgs apply-labels writes them to IMAP.

Why the agent can reach my LAN at all

This is the part I like most, because it's a deliberate decision rather than an accident.

An agent box on a hachiflow machine has egress through a vault. By default the vault refuses private addresses, which is the right default for a hosted machine running next to hachiflow's own services. But a machine I bring myself sits on my network, and I am the one who put the agent there. So on a self-hosted machine with open egress, the box may reach the RFC 1918 ranges (10/8, 172.16/12, 192.168/16) plus IPv6 unique-local addresses. That's how the agent reaches Bridge and the Jev server on the gaming PC.

Some lines stay closed. Loopback, link-local (which includes cloud metadata at 169.254.169.254) and CGNAT stay refused. And credentials don't follow the traffic: the vault only swaps a real secret in for a host that a lease names, and a lease names hosts by name, never by IP. A request to 192.168.50.20 goes out with nothing secret attached. If I ever want the old behavior back, one setting turns it off (RUNNERD_PRIVATE_NETWORK=off).

You can see it in the machine record: sandbox.level: docker_desktop_vm, hardened: true, egress: open, lan_reachable: true. The box is a real sandbox that can also talk to the machines in my house.

The agent, as a spec

Everything about the agent is one spec. This is what hachi export-spec --workspace origin prints for it, with the instructions trimmed:

version = 1

[[workspace]]
key = 'origin'
name = 'Origin'

[[workspace.agent]]
name = 'inbox-zero'
runtime = 'claude'
always_on = true
instructions = """
You are Akeem's inbox-zero agent. Every hour you drive his ProtonMail
mailboxes toward empty with the `higgs` CLI ...
"""

[[workspace.agent.schedule]]
title = 'hourly-inbox-zero'
prompt = 'Run the inbox-zero routine on all three mailboxes now and send the short report.'
minutes = [0]
hours = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23]
weekdays = ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun']
timezone = 'America/Denver'

hachi apply is idempotent, so this file is the agent. When I run it a second time, every line reports noop. A changed instruction becomes a single update.

always_on = true keeps one warm desktop container between turns instead of starting a fresh one for every wake. While I was bringing the setup up, that let me open the agent's desktop and watch it work.

The rules it runs by

The instructions are the real product here, and most of them are guardrails. A few that matter:

  • Preflight, or stop. Every run first checks that Bridge answers (higgs search INBOX --limit 1 must end with its summary line) and that the Jev server is healthy (curl http://192.168.50.20:8791/health). If Jev is down, the agent waits for the next hour. It doesn't fall back to another model, because a fallback is how mail ends up somewhere I didn't choose.
  • Classify first. Nothing is archived, trashed or moved until Jev has labeled it. There is no blind archive by date.
  • Never send. higgs send is forbidden. The agent may save a draft for mail that really needs a reply, and I send it myself.
  • Dry run every mutation. The agent runs unattended, so after a dry run it goes ahead only for the safe categories. Everything else stays in the inbox and goes in its report.
  • A topic is not a bulk signal. "Jobs" or "Health" doesn't mean "archive." Bulk means is_mailing_list, an obvious bulk sender, or a recurring broadcast that needs nothing from me. Replies, forwards, people, family and my kid's school stay put.
  • The 90-day rule. Once it's classified, anything older than 90 days is archived whatever it says. Obvious third-party spam is trashed, not archived.

Some of the rules are about the model specifically, because a 2B decision model has quirks and the instructions say so plainly. Jev's confidences run low, so the agent doesn't filter on --min-confidence. Jev sometimes marks real to-dos as bulk, so before any bulk archive the agent scans each row for words like failed, declined, past due, expires and appointment, and keeps the live ones. Jev also tags GitHub CI mail as "Jobs," so that label is ignored for CI mail. A small model plus explicit rules about where it goes wrong beats a big model I have to trust.

The safety story from the higgs post still holds, and the isolation strengthens it. Every email is attacker-controlled text. Jev can only answer with one of the labels it was offered, so the worst a hostile message can do is argue for its own misfiling. The agent can't send mail at all. And the agent itself is a separate identity with its own key, in its own box, on its own machine. It doesn't hold my keyring, my laptop session or my shell.

What the first night actually looked like

I set this up tonight, and the run history is more honest than any demo, so here it is.

The agent was created at 19:14 UTC. The first scheduled runs found no Bridge login in the box. Each one ran its preflight, got a 401 from higgs search, and reported in a few seconds that it was waiting on me. In its own words: "preflight failed (3rd run in a row) ... Not working around auth. No mail touched in any mailbox." That's what I want from an unattended agent with write access to my mail. It refused, said why, and touched nothing.

I put Bridge on the gaming PC and gave the agent the login. On the next turn, the run's credential log shows the box calling 192.168.50.20:8791, the Jev server on my gaming PC, and classify batches going through it. That's the whole point of the setup: an agent on the Mac mini, reading my mail with a model on the gaming PC, over my own LAN.

That turn didn't finish the backlog. A first pass over years of mail is a lot of classify batches, and the turn hit its 50-turn limit while a batch was still running in the background. It stopped cleanly with no half-applied labels, because labels are only written after classify finishes. The hourly schedule picks up where the last run left off, since higgs checkpoints its state in SQLite. The backlog drains a few hundred messages at a time, and after that each hour only sees what arrived in that hour.

What I traded

This setup isn't free, and I want to be precise about the cost.

  • Speed. A 2B model on a gaming PC is slower than a hosted API, and the first pass is long. For an hourly job that doesn't matter.
  • Availability. If the gaming PC is off, there's no classification and the agent waits. If Bridge is down, there's no mailbox. Both are dependencies in my house, which is the point, and also the cost.
  • Where the line is. The agent itself runs on Claude, so the agent's own reasoning goes to Anthropic. What it sends there is the same as in the higgs post: subjects, senders, Jev's labels and confidences, and the counts it reports. The message bodies are read on my gaming PC. I drew that line on purpose, and I know where it is.
  • Judgment. A decision model is great at "which bucket" and weak at "does this need me." That's why the instructions carry so many keep-it rules, and why anything ambiguous stays in the inbox for me.

The setup I always wanted

An isolated agent, always on, on a computer I own. Inference on a GPU I own. AI that does the boring 95% of my inbox every hour, privately, and leaves me the 5% that needs a person.

If you want to build the same thing:

The backlog is draining as I write this. Once it's gone, the agent's job is the next hour's mail, every hour, read by a model on hardware I own.

TransmissionsNEWSLETTER通信