THE AGENT PLATFORM

An autonomous multi-agent operations platform, governed by a constitution and run on receipts

Platform ArchitectMulti-agent / LLM orchestration / Operator console2025 — NOW

The Problem

Unattended AI systems fail in ways that are hard to inspect and harder to trust. Take a daemon that works overnight, runs commands against a live homelab, and makes decisions for a person it can't check with in real time. By default, nothing in its structure keeps it in bounds. Sooner or later it will do something the operator didn't authorize, and there will be no record of how it decided to.

The usual fix is to restrict what the system can do: short context, tight scope, and a human in the loop at every decision. That swaps one failure mode for another. A system that needs constant human input is just a complicated interface.

So the problem is autonomy you can't inspect. The question is whether a system can act with real authority inside explicit limits you can verify: floors it can't cross, a record of every material action, and a way to turn each failure into a permanent rule instead of a one-off correction.

System diagram showing three AI daemons receiving commands from a private operator console, passing through a guard stack, and acting on self-hosted infrastructure.
SYSTEM DIAGRAM — THREE-DAEMON FLEET WITH GUARD STACK

The Solution

I designed and run a fleet of three always-on AI daemons on self-hosted infrastructure. I operate it from anywhere through a private, authenticated console, with no laptop required. Work runs autonomously overnight, and a morning digest is the main interface.

The design rests on three ideas. First, governance belongs in the structure, not in a policy. A written constitution of seven articles, adversarially red-teamed and then ratified, sets floors no daemon may cross, whatever it's told: no auto-merge, no autonomous spend, no outbound messages to external parties without approval, no deletes without human approval, and no secrets leaving the host they live on. Pre-execution checks enforce them as hard gates, and an outbound guard stops credentials from leaving the system.

Second, verification is adversarial and independent. The daemon that builds something doesn't verify it. Conductors spawn separate builder subagents, and verification goes to a different model or a different daemon whose job is to refute the work, not confirm it. The governance document states that a subagent the builder spawned isn't independent, and the dispatch structure enforces it.

Third, every material action leaves a receipt on disk. If work exists only in a context window, it doesn't exist. The corpus holds 1,564 work receipts from March through July 2026, written incrementally during execution, not reconstructed afterward.

The floors are what let me trust the system to act without asking for permission every time.

Architecture

Governance as Architecture

A written constitution of seven articles governs the platform. An independent adversarial red-team raised 27 findings, all addressed. It was then hardened, ratified by me as the principal, and put under version control. Only the principal can amend it. It also states explicitly that an agent which reinterprets an article to unblock itself has violated it.

The floors are enforced in code, not by convention. A pre-execution gate catches destructive commands and holds them for human approval. An outbound guard keeps credentials from leaving the system, and untrusted inbound content is screened before an agent acts on it. These guards fire before the model can produce a harmful response, so the model's reasoning about whether to comply is never the last line of defense.

Hard Floors — No Exception
01No auto-merge, no auto-send, no autonomous spend
02No deletion without explicit human approval, in any mode and at any autonomy level
03Secrets never leave the host they live on. Agents may confirm a secret exists, never its value
04No outbound messages to external parties without principal approval
05No SSH, firewall, or network configuration changes without explicit grant
06Caged paths are absolute: never read, scanned, or written, in any context
07Observed floor violations are reported in the next message regardless of silence discipline

The constitution also spells out what "verification" means. A green signal has to measure the real quantity. "Job ran" is not the same as "artifact exists." "Tests pass" isn't verification if the test doesn't exercise production code. A detector that inspected zero items reports NO-DATA, never PASS. Each of these rules comes from a failure the system actually hit, documented, and turned into a permanent rule.

Craft Details

The lessons archive. Every failure becomes a lesson in a permanent, append-only archive. At the time of writing it holds 160 lessons, covering prompt injection defense, liveness detector design, incident triage discipline and multi-agent contention patterns. A hot-load index carries each lesson's headline, which states the rule in a phrase, and the full text is read on demand when a situation matches. The system doesn't re-learn what it already knows.

Conductor / builder separation. The planner daemon breaks tasks down and dispatches them to builder subagents. Builders write code and receipts, and the conductor verifies. The builder never spawns the conductor's verifiers, and for decisions above routine tier a different model family is preferred for the verification pass. By written policy, a subagent the builder spawned never counts as independent.

Liveness watchdogs. Each daemon writes a session-state file at step boundaries and whenever it becomes blocked or finishes. After a restart it reads that file and resumes warm instead of cold-starting. The watchdogs tell a heads-down conductor, whose own session log goes quiet while its subagents keep working, apart from a daemon that has actually frozen. They have to: a false-positive restart mid-task strands in-flight work with no handoff.

Multi-model spine. The platform mixes hosted frontier models with local open-weights models running on self-hosted inference at interactive speed. That's a stated design goal: model-agnostic infrastructure, so no single model family becomes a dependency. Expensive frontier models make the judgment calls and do adversarial verification. Cheap local inference does the volume work. The local model is never used for grading or judicial decisions.

Memory corpus. 406 persistent memory files sit behind a 121-entry curated index. Each index entry is a one-line recall hook, and the full file is read on demand. Shared memory is split by daemon role: each shared file has one owning daemon, and the others add to it only through append-only paths. Sensitive memory is under integrity monitoring, so tampering shows up instead of spreading silently.

The most common failure on the platform is a green signal that measures nothing. A detector that inspected zero items reports NO-DATA, never PASS. No rule appears in the lessons archive more often.

Three Incidents, Three Lessons

Here are three real incidents from the verified record. Each one has a documented root-cause writeup in the lessons archive.

I-01
SYMPTOMTraffic between machines stopped while every local check kept passing. No error surfaced in any service log.
ROOT CAUSEA host network setting had a side effect, and reverting the setting did not revert the side effect, so the outage outlived the change that caused it.
LESSON SHIPPEDInfrastructure changes must be verified across the whole fleet, not just on the host that changed. One green host doesn't mean a green fleet.
I-02
SYMPTOMThe fleet-wide liveness watchdog reported a network outage. Multiple services were flagged as unreachable, and the alarm fired at the same moment on unrelated hosts.
ROOT CAUSEA scheduled maintenance job briefly froze monitoring, which caused the false alarms. The network wasn't the cause. The alarm came from a planned pause.
LESSON SHIPPEDA liveness detector has to tell a planned pause from real silence. Unrelated hosts firing at once points to one shared trigger, not N independent failures.
I-03
SYMPTOMA mute rule appeared correctly in the configuration file. The muted alert kept firing.
ROOT CAUSEThe rule was written down but was not in effect. The config said one thing and the alert said another.
LESSON SHIPPEDYou verify a mute by watching the alert stop arriving, not by finding the line in the config. A rule on disk is necessary, but it isn't enough.

Stack

Multi-agent orchestrationLLM orchestrationOperator consoleLinux servicesVirtualizationLocal open-weights modelsLocal inference

Result

The platform operates a homelab and a portfolio of personal systems across three persistent daemons, a small self-hosted cluster, and a multi-model inference layer. It runs overnight, handles incidents, writes code, manages deployments and produces a morning digest, with no human intervention needed for routine operations.

Honest capability statement, verified numbers only: 3 always-on daemons, 160 append-only engineering lessons, 1,564 receipts on disk, 406 persistent memory files, 50 installed skills, a layered guard stack, and a security pipeline whose end-to-end alert delivery was verified by synthetic injection.

MTTR, uptime percentage and cost savings in dollars are UNMEASURED. The instrumentation exists, but the baselines haven't been formalized, so I won't cite those numbers until they're measured.

The main output here is a working answer to one question, not a product: can an autonomous AI platform really be trusted to act without supervision? The constitution, the lessons archive, the receipts and the guard stack are the evidence, and they outlive any one model's weights.

Work that exists only in a context window doesn't exist. Everything material leaves a receipt on disk, written incrementally, not reconstructed afterward.