Dan Bennett
← Back to portfolio

Personal Ops Orchestrator

Live

As I ran more AI agents in parallel, keeping tabs on all of them — plus a flood of Dutch-language email as a new-country parent — got overwhelming. So I built an orchestrator that runs overnight on a local model, reads and translates my email, reconciles my task list, and leaves me a single prioritized daily brief. Daily production since early 2026.

Orchestration Local LLM Autonomous Agents MCP Guardrails

The Problem

Leaning into AI created a new problem. The more agents I had working in parallel — across CREOpsDesk, Burrfect, the n8n work, and side projects — the harder it was to keep tabs on what each was doing and what actually needed me next. Then I relocated to the Netherlands with my family, and overnight my inbox became a flood of Dutch-language mail: childcare invoices, health insurance letters, school notifications, government correspondence, all mixed in with English work email and Burrfect business. Missing a payment deadline because I could not parse a Dutch email at 7 AM while wrangling two kids was a real risk.

I did not need another chatbot. I needed something to stay on top of the status of everything, translate and triage what mattered, and hand me a short, prioritized plan each morning, so my limited focus could go to decisions instead of catching up.

What I Built

An orchestrator for my own operations. It runs overnight, keeps tabs on the work my agents did while I was asleep or with the kids, and produces a single daily brief: prioritized tasks, the emails that matter, and where each project stands. The privacy line is deliberate — the parts that read my inbox run on a local model, so personal and client data never leave my machine.

The overnight brief, on a local model

The brief is produced by a three-job pipeline a bash script fires at 5:00 AM via a macOS LaunchAgent:

  1. Base briefing (cloud): a scheduled Claude job generates the strategic layer — priorities, calendar, focus, English-email highlights — and writes a task-list backup snapshot.
  2. Local enrichment (privacy boundary): a local Qwen model (4-bit, via LM Studio on Apple Silicon) reads my email on device, then runs an agentic tool-use loop that searches Gmail, translates and categorizes the Dutch mail, cross-references it against open tasks, and weaves the results into the briefing. Email content never leaves the machine.
  3. Task reconciliation: the model produces a JSON changeset (create/update/complete); deterministic Python validates and executes each change through Blitzit's MCP API, logs field-by-field diffs, and appends a changelog.

The output is an interactive HTML brief published to a local docs server and reachable from any device over Tailscale — each task row has a checkbox wired to its Blitzit task, so I can clear items from my phone before the kids wake up. Roughly 2,200 lines of production code, running daily since early 2026.

Keeping tabs across projects

It tracks the state of work across repositories that have to stay in sync — for example a Django app, its n8n workflows, and its browser-automation scripts living in three different repos — so a change in one place does not quietly break assumptions in another.

Autonomous work, with guardrails

It delegates implementation to sub-agents, but never fire-and-forget: structured review checkpoints, test-driven development, verification before anything is marked done, and explicit approval gates for destructive operations.

Memory that persists

It connects to a shared memory server (Hindsight) over the Model Context Protocol, so decisions and project context carry across sessions instead of being re-explained each time.

Design Decisions That Made It Reliable

Deterministic where possible, LLM only for judgment. Each local-model turn takes 30–120 seconds at this context size, and LLMs are unreliable for structured operations. So a pure-Python pre-filter answers "is this email still relevant?" (thread-ID matching, set operations, API calls) before the model runs, and the diff engine, backups, HTML conversion, and fuzzy task matching are all deterministic. The model's job is strictly: read email content, judge priority, produce structured output.

Guardrails are not optional. My first hard lesson was a re-creation loop: the model would see a Dutch email, create a task for it, then the next day see the same email and create another. The fix — a completed-thread-ID guard that builds a set of already-handled threads and blocks the model from acting on them — turned out to be the single most important architectural decision. Deterministic guardrails constraining an LLM's action space is the pattern I reach for first now.

Observability pays for itself on day one. Every tool call is logged with timing; every task change with before/after diffs; the raw model output is saved. When something goes sideways at 5:30 AM, I can read the log and know exactly which turn, which tool call, and which email caused it.

Two providers, each doing what it is best at. Claude (cloud) handles strategic synthesis and English business context; Qwen (local) handles the privacy-sensitive email reading. The local step adds to Claude's work rather than replacing it.

How It Is Built

The working parts are a set of reusable Claude Code Skills: structured, multi-step workflows with guardrails, validation checkpoints, and hard-won operational patterns baked in — systematic debugging, test-driven development, code review, verification-before-completion, and plan-writing. Each one exists because I hit a real problem in daily use and encoded the fix so it would not recur; roughly a dozen and a half run in production today.

The Result

It has been in daily production use since early 2026. Every morning starts with a brief that has already processed overnight email, translated Dutch communications, and reconciled my task list. Cross-repo work stays coordinated without me tracking it by hand, and autonomous agents handle implementation with guardrails while I spend my focus on product decisions.

For a business owner onboarding AI, this is the piece that is easy to miss: the hard part is not spinning up more digital assistants, it is staying on top of the ones you already have.

Tech Stack

  • Foundation: Claude Code
  • Workflows: a suite of reusable Claude Code Skills (structured multi-step procedures with guardrails)
  • Orchestration: bash (run-overnight.sh), macOS LaunchAgent (5:00 AM), Python (marvin_overnight.py, blitzit_sync.py, convert_briefing.py)
  • AI Models: Claude (cloud, strategic briefing) and Qwen 35B (local via LM Studio on Apple Silicon, M2 Max 64GB, for privacy-sensitive email reading)
  • Integration: MCP servers — Hindsight memory, Gmail, Blitzit, Google Calendar, Google Drive
  • Delivery: interactive HTML on a local docs server, Tailscale for mobile access; JSON backups with tiered retention (daily/30d, weekly/1yr)