The companion episode — Aillex introduces the agent that runs her life.

A chatbot answers when spoken to. An agent wakes up on its own, does work, checks the work, and ships it. Everything our channel publishes daily is produced by one — a local model in a harness, on one PC. This guide is the pattern.

The pattern: brain, harness, gates

  • Brain — a local LLM (we run ours in Ollama). It decides.
  • Harness — the body around the brain: a loop (watch for things to do), tools (things it may use), memory (what happened), and a schedule (when to wake). It enables.
  • Gates — checks between the agent and the public internet. They protect.

Scripts follow steps; agents make calls. The harness is what turns “a model” into “a colleague.”

The brain (and why it’s swappable)

Any capable local instruct model works. Two hard-won rules:

  1. Turn extended “thinking” off for chat loops. Reasoning modes are brilliant and slow — minutes of silence before the first word kills an interactive agent. Most models expose a switch (system-prompt directive, API flag, or a no-think variant).
  2. Benchmark on the agent’s real chores, not vibes: does it follow tool instructions? Is its structured output clean, or wrapped in markdown clutter that breaks parsers? How fast is the first token? We benchmarked a newer model against our incumbent on exactly those three axes and swapped brains with one config line. That’s the point of local: the brain is a file.

The body

  • Tools via MCP. The Model Context Protocol is a standard plug: snap servers onto the agent and it gains their tools (ours boots with 67 — image generation, web search, file posting…). The agent doesn’t know how to do these things; it knows when to call them.
  • Skills. Named recipes for multi-step jobs (“produce the daily video”), written so a failed step retries or falls back instead of killing the run.
  • Memory. Start embarrassingly simple: append-only logs and notes-to-self in files. Our AI collaborators literally share a dev log — each session reads where the last left off. Continuity without a vector database.
  • Schedule. Cron or systemd timers. One rule that will save you: make timers persistent (fire on next boot if missed) — machines reboot at the worst times.

The gates (the part that makes it shippable)

An unattended agent needs veto points:

  1. A QC gate — a second model checks the work product (we use a vision model to read rendered frames: captions right? faces intact?). Fail → re-roll, don’t ship.
  2. Editorial rules — encode your policies in the prompts, and when external evidence contradicts the agent’s judgment, the evidence wins.
  3. A human pick — anything new (a new look, a new format) goes to a human as options, not actions. The agent does labor; taste stays human.

Reliability: everything fails silently

The dumbest outage we ever had: the watchdog that kept the agent’s VM alive died successfully — its job “completed” when the VM did, so the scheduler never restarted it, and we ran uncovered for two days. The fixes cost an afternoon:

  • a heartbeat: a timestamp appended to a file every 5 minutes — gaps show you exactly when things died,
  • a black box: telemetry written outside the VM, so the final seconds survive a crash,
  • a watchdog for the watchdog — restart-on-success is not restart-on-failure; check which one you configured.

Rule of agents: anything that can fail silently, will. Make it fail loudly.

Start this weekend

  1. Install Ollama + pull a mid-size instruct model.
  2. Pick an open-source agent harness (several good ones exist — look for MCP support, skills/plugins, and cron).
  3. Wire ONE tool and ONE scheduled job: a morning summary written to a file.
  4. Let it run a week before it may touch anything public. Then add your first gate.

The agent that runs our channel is the subject of the companion episode on YouTube → @AskAillex. When your agent needs to make pictures, the whole Engine Room series is here. Show us what you build: r/aillex.