Skip to content

The platform path

I build the platform the agents stand on, and I make it regenerable from its source.

Status: in daily use · checked Oct 26, 2026

In plain terms

Everything the agents do sits on a small platform of layers I also run. The rule that holds it together is that configuration lives in one place, in files, and the running system is generated from it. Adding a new service goes through a path that makes it inherit things like authentication, alerting and backups instead of skipping them.

The agent system on the other pages is the top of a stack. It is the layer I changed most this year, but it only works because the layers under it behave. The ideas that make it manageable are configuration as the source of truth and a governed path for anything new.

The layers

  1. Agent control plane: dispatch, ledger, orchestration, gates
  2. Alerting and incident handling
  3. Observability: metrics, logs, traces, probes
  4. Runtime and restart ordering
  5. Configuration and provisioning
  6. Identity, secrets and access
  7. Network and firewall
  8. Physical hosts and appliances

A layer depends on the ones below it, and a change at the bottom ripples upward: a network change reaches every service, a plan reaches down through whatever it touches. The whole environment is 9 main machines (as of Oct 2026). The top layer is described in lanes and the run ledger, orchestration and reliability; the observability and alerting layers in observability.

Configuration is the source of truth

The rule across all of it: the canonical configuration files and templates are the truth; the running system is derived. Service definitions, reverse-proxy routes, name-resolution entries, unit files and firewall allowlists are all rendered from templates and a small set of shared data files. These habits keep it that way.

  • Edit the template, never the output. A hook stops an agent editing a generated file by hand, because the next render would silently revert it. A commit-time check refuses a change to a live file that has no matching change to its template. Both are described in guard rails.
  • Preview before applying. Rendering has a dry-run mode that prints the difference between what would be generated and what is live. That diff is the unit of review, and it is run against the host it concerns, because a diff taken on the wrong machine reads clean and means nothing.
  • Drift has a direction. When the live system and the template differ, the first question is which side is ahead. Sometimes the template is stale and someone fixed the live system; sometimes the live system is stale. I read the template and its history before resolving, rather than assuming one side wins.

The same principle applies to the numbers on this site, which come from one values file and are checked by a test, and to the documents, which carry their own evidence and age (documentation that stays true).

A governed path for anything new

Adding a service is where good platforms rot, because each new thing is easiest to add without the boring parts. So the path for a new service is a planner, not a checklist someone remembers. It asks a handful of architectural questions and emits a multi-lane plan (orchestration) that already covers every cross-cutting concern:

Concern What the plan includes
Code and build the service definition from a template
Secrets a scoped identity that reads its secrets at run time, with no keys on disk
Network the segment, the firewall allowance and the port registration, together
Ingress the route and the authentication pattern chosen from a short list of lanes
Names the entries, added where the source of truth for names lives
Monitoring a scrape target, a dashboard and an alert with a runbook link
Boot order its place in the tiered start-up graph
Backups the recovery class it belongs to
Documentation its page, with state and evidence

A governed service inherits authentication, logging, alerting and restartability, because the archetype encodes them.

The start-up graph is itself a design decision: services start in tiers, with the networks first, then identity and name resolution, then the gateway, then exporters, then applications. A hard dependency between tiers once turned a restart of the container engine into a full teardown of everything that depended on it, so the dependency was softened where start order matters but a restart should not cascade.

Rolling out and rolling back across machines

A change counts as done when it is running on every target it was meant for, and I measure that instead of assuming it.

  • Merged isn't running. A delivery-chain view has a live column that reads what each host is actually running, set against what was merged. Where the answer can't be determined, it counts as red, not as green.
  • Version lag is an instrument. The shared agent tooling is delivered to every host from one kit. How far each host lags behind the current kit is measured, because a fleet where hosts run different versions of the guards is a fleet where the guards mean different things.
  • Staged, not all at once. The decision record for live deploys locks a canary host first, then a health check, then the rest. The apply is two calls: the first call prepares, arms a rollback and mints a confirmation, and only a second call, driven by a human, executes, so an unattended agent can make the first call and never the second.
  • Workers run on more than one operating system. The agent workers run on Linux hosts and on a Windows machine, and which hosts may run agentic work at all is a per-host grant, denied by default.
  • Rollback is local and explicit. A self-canceling rollback timer protects a single risky change on a single host (guard rails). Reverting a template and rendering again is the rollback for configuration.

Failover. Each function that fails over declares its chain once, in a registry. DNS resolution, speech-to-text routing and event publishing each list their tiers in order, what flips to the next one, how the service returns to the primary, the alert that fires while it is off the primary, and the check that shows which tier is active.