AI, wired in
AI is both how I built AutomationLab and part of how it runs - held to the same discipline as everything else: a design before code, human review on every change, and cost-gated and audited like any other dependency. It writes syntax; I own the planning, the architecture, and the decision to merge.
How I build with it: multi-session Claude Code
The lab is built with four parallel Claude Code sessions held to a rigid process: a
design doc before any code, one PR per change, a runbook for every pipeline, and mandatory
human review - I read and approve every PR before it reaches main. The model is
fast at the part I deliberately stopped memorizing (syntax from scratch); the planning, the
trade-offs, and the merge decision stay mine. The workflow runs against the same branch
protection and CI gates as any other contributor, because a machine author is not an excuse to
lower the bar.
Pipelines, not prompts
AI work is not ad-hoc chat; it runs as pipelines with the same guardrails as everything else - secrets fetched at run time, outputs recorded, fail-closed gates. Nothing an AI produces reaches production without passing the same lint, security-scan, and review gates a human change does. The AI is a contributor inside the process, never a bypass around it.
AI in operations: agents that triage, analyze, and report
AI is not just build-time. Agents run inside the platform as scheduled and event-driven jobs:
- A morning triage chain. Collectors gather signals across the platform - metrics, monitoring, CI, and backups - an LLM triages and correlates them, and a short daily digest lands before I sit down. Novel high-severity patterns become tracked findings, not lost noise.
- Incident enrichment. When something fails, an analyzer summarizes the failure inline with the alert, so the first thing I read is context, not raw logs.
- Scanner triage. Vulnerability and secret-scanner output is triaged by an LLM into exploitable-in-context vs likely-noise verdicts, so a wall of findings becomes a short list worth acting on. The scanners find; the model prioritizes - it never invents a finding.
Every one of these is advisory by construction: the AI proposes, a human approves and applies. Log content and scanner output are treated as untrusted data, delimited and never allowed to steer the model.
Local LLM plus the Claude API: the split
Two models, chosen by fit. A local, self-hosted open-weight LLM does the high-volume, zero-cost, privacy-sensitive work - triage, summarization, classification - and never leaves the network. The Claude API is reserved for the harder reasoning where it earns its cost. A single gateway fronts both, so every call is routed, keyed, and metered in one place, and swapping or adding a model is a config change, not a rewrite. Local-first is the default; the paid path is the exception.
Cost gating: spend that cannot run away
AI spend is governed by layered, most-restrictive-wins budgets: a per-consumer key budget, a global gateway ceiling, and a fail-closed monthly credit gate that stops spend before it overruns rather than reporting it after the fact. The layers are independent, so no single misconfiguration opens the tap. Because the local model carries the bulk, the actual bill stays near zero - the gates exist to guarantee it, not to explain a surprise.
Auditing and the trust boundary
Every AI action is advisory and logged. Triage verdicts, self-heal outcomes, and escalations are recorded so the reasoning is reviewable after the fact - the same audit posture the rest of the platform holds. The line between proposes and does is hard and human-gated: an agent can recommend a fix, open a draft, or raise a finding, but it does not cross into applying a change on its own. AI earns trust the same way every other part of the lab does - by being reviewable, bounded, and honest about what it did.