Parallelogramist

AI-Ops: the Operator Loop

building · overview

This page is a short honest summary of what it is and the key decisions, not a full case study. Source status: write-up only: the code stays private; this page is the public artifact. Withheld: The fleet's guard hooks, schedules, and host identities are the security surface of a live home system; the loop's design and decisions are documented here.

A self-improving loop for automating my own life that hands back more time than it costs to run, and prunes itself when it doesn't. The system behind this whole site.

always-on box
automationmethodologyclaude-code

The brain of the whole initiative, and the reason this site exists. A loop that runs on a fixed cadence: observe where my time actually went, score a backlog of candidate automations by the value they return divided by what they cost to keep alive, let me choose exactly one to build next (or nothing), build it as a reversible draft, adopt what proves itself, prune what rots.

Two ideas do the heavy lifting. Maintenance cost sits in the denominator of the score, so anything that needs constant babysitting self-prunes. And protected family time is config the system is forbidden to schedule over: the loop’s job is to hand time back, never to take it. “Build nothing this week” is a valid, healthy outcome.

This site is its public face: the method and the wins, written up plainly enough that you could build your own version.

Ship history

The scheduled jobs finally got a supervisor

The long-running services here had two watchdogs between them. The scheduled jobs had none, so a failed run could sit failed for days with nothing noticing. A repair daemon now sweeps them every few minutes: it re-runs what a re-run can fix, under a strict per-job attempt budget, and escalates rather than looping on what it cannot. Its first night repaired three failures on its own and escalated one when the budget ran out.

Docs that point instead of copy

A guide that keeps its own copy of a live value goes wrong silently and stays wrong: one line named a default the code had changed 28 days earlier. Twenty repositories now cite the file that owns each value instead of restating it, and a weekly report-only checker compares whatever the docs still restate against its source.

The build fleet gained a legible, dependency-ordered ready queue

Each repository's backlog now triages into a scored, dependency-ordered queue instead of agents guessing what to pick up next. Shipping it surfaced a same-day insight: the queue's machine-readable data now lives in its own JSON file instead of being re-parsed out of the markdown written for a person to read.

The fleet split planning from execution

Each repository's work is now planned by an agent on the strongest reasoning tier (it makes every judgment call and writes one executable plan file) and implemented by a separate agent on a cheaper, faster tier that follows the plan exactly. Forced by a real capacity crunch: a hard usage cap on the top tier had stalled whole batches of work.

The fleet supervisor got a dead-man backstop

A reworded usage-limit message evaded the watchdog's pattern-matching and wedged every fleet slot for hours while the dashboard read all clear. The targeted fix teaches the classifier that message; the class fix presumes any agent that stays silent and unclassifiable for an hour is dead, and frees its slot.

Family-time defense, live

The first always-on guardrail landed: an automation that defends protected hours, so the loop can never schedule over them.

Three report-only automations built

Defend, brief, and triage run report-only by default: they surface a recommendation; a human adopts each one before it ever acts.

The Operator Loop, scored

A scored leverage ledger turned the next-build choice into a ranked, upkeep-aware decision instead of a guess. Toil that costs more than it saves self-prunes.

← all projects