THE AGENT PLATFORM
An autonomous multi-agent operations platform, governed by a constitution and run on receipts
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.

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.
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.
Stack
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.