Plant — a one-person engineering org

Plant is the infrastructure that lets one person operate like a full engineering organisation — planning, implementation, delivery and monitoring all wired together. It isn't a product for sale. It's the force multiplier I built for myself, and the clearest proof of what I claim on a call: that the right person, with the right system around them, ships at a pace that normally takes a team.

Seven services, five languages, one operator. Ideas come in from a dozen sources — voice, links, PDFs, papers, a browser extension, Slack — and land in a knowledge graph (Spark), which runs a multi-turn planning session with Claude Code and emits a structured plan with tasks, dependencies and acceptance criteria. That plan is served to AI agents through a task manager built for machines, not humans (Board). An autonomous loop picks it up and implements it (Ralph), one task per iteration, inside cheap isolated sandboxes on an AWS spot fleet (Reactor). A native macOS app schedules overnight runs (Chief), a conversational manager orchestrates the whole estate over MCP (Foreman), and a Rust telemetry core records every agent event so the system can watch itself (Telemetry).

The engineering judgment that makes it work — and that I bring to client systems — is in a handful of contrarian decisions.

the decisions that make it work

• Externalised state beats context accumulation.

  Most agent frameworks lengthen the conversation and fight context-window decay. Plant deletes conversation between iterations entirely. Tasks live in Board, code lives in git, learnings live in the codebase — so a loop runs for two hundred iterations without quality collapse. It's the single bet the whole platform is built around.

• Objective completion verification, not the model's word.

  When an agent claims a task is done, Ralph doesn't believe it — it checks Board's task statistics and, on a mismatch, records what's still missing and continues. A circuit breaker halts runaway false-completion loops. The LLM proposes done; an external service decides.

• Tooling built for agents, not adapted from human tools.

  Board's primary user is an LLM: one call bootstraps an agent with everything it needs, in a compact format roughly 80% smaller than the full payload, and dependency-aware about which tasks are actually available.

• Code Mode.

  Foreman generates a typed TypeScript API from MCP tool schemas, so the model writes code against a typed surface instead of emitting one tool call at a time — fewer round-trips, fewer hallucinated arguments.

• The system watches itself.

  A daily self-reflection routine reads the telemetry, detects its own latency and token regressions, and files corrective work back into the pipeline.

• It builds itself.

  Every one of the seven repos is developed using the autonomous loop. The loop builds the platform that runs the loop — every iteration is a flight test, and the volume of tested, deployed output is the evidence.

What it is: a real, self-hosting platform doing real work. What it isn't, and I'll say so: a commercial product. Test coverage is deliberately uneven, and several conveniences suit a solo operator and would need hardening for multi-tenant use. Same standard I'd hold your system to.

The reason this is the work I lead with: it's the discipline of the whole practice in one artifact — agent orchestration, evals, anti-hallucination verification, retrieval, observability, and the taste to pick the right language for each layer — built and shipped by one person.