FOUNDER OS

A goal-to-execution command center: send a goal from anywhere, wake up to receipts

Product ArchitectOperator console / agent orchestration / morning digest2025 — NOW

The Problem

A solo founder's time is the bottleneck, and every tool that promises to save it demands attention in return: open the dashboard, review the queue, approve the draft, close the loop. Running the interface becomes the job.

Automation frameworks make it worse. A Zapier flow saves the click but not the monitoring, and a cron job saves the scheduling but not the verification. Someone still has to watch the output, catch failures and flag what matters. Usually that's the founder, at 11pm, on a laptop.

I designed for zero-laptop operation instead. I send a command through a private operator console from wherever I am. Agents break it down and run it overnight, and the next morning's digest brings back outcomes, receipts and any decisions that need a person. I review it in five minutes, approve what needs approval and get on with my day.

System diagram showing the goal-to-execution command loop: operator console to command router to three AI daemons executing overnight to morning digest with approval cards.
SYSTEM DIAGRAM — GOAL-TO-EXECUTION OVERNIGHT LOOP

The Solution

Three always-on AI daemons run as supervised services on self-hosted infrastructure. Each daemon has its own role (curator, operator, planner) and strict write-rights, so no two agents can corrupt the same files. They share a filesystem, each one works in its own git worktree, and session state resumes after a restart, so a reboot doesn't strand in-flight work.

Commands come in through a private, authenticated operator console. I send a goal from anywhere, and a command router (15+ commands) passes it to the right agent lane. The agents plan, break the work down and carry it out: searching, writing, filing, building, and running subagents for parallel workloads. Everything material writes a receipt to disk as it runs, so an API error mid-task doesn't lose work.

A morning digest turns the overnight receipts into a structured briefing: what ran, what finished, what needs a decision and what to ignore. I see the outcomes, not the operations behind them.

I send work through a console and review it in a digest, from anywhere.

Craft Details

The approval-card pattern. The system keeps a hard line between what the agents can do on their own and what needs my explicit sign-off. Outbound communications, spend, destructive operations and network/security changes are propose-only. The agent writes the proposal to disk, shows it as an approval card in the digest and does nothing more until I respond. The card says what the agent wants to do, why, and what the one-command revert is. I approve by replying. Silence or a “no” means no.

Silence discipline. Agents message me in three cases only: blocked (missing credentials, a conflicting spec, an unclear destructive step), done (task complete, with receipts), or approval needed. They send no progress updates, lint-error notifications or “working on it” acks. My phone stays quiet while the system runs.

Task receipts. Every unit of work leaves a receipt on disk before the session ends. The corpus holds 1,564 work receipts (1,002 active, 562 archived, March through July 2026). Receipts do two jobs. They're the ground truth for the morning digest, and they're the handoff when a daemon restarts mid-task: the new session reads the receipt and picks up where the old one stopped, so no work starts over.

Engineering lessons as living policy. Every incident, correction and system failure gets an append-only lesson entry. The corpus now holds 160 lessons on failure modes in networking, container orchestration, LLM session limits, multi-agent contention and cross-browser rendering. Every new agent session loads the lesson index at startup, so the system remembers a mistake even when no single agent does.

Trigger classHandling
Outbound communicationsPropose → wait for approval → send
Destructive operationsHuman-approval hard stop
Spend / purchasePropose → wait for approval → execute
SSH / firewall changesExplicit human approval, no exceptions
SecretsNever leave the host; only their existence is confirmed

Defense in depth. The system runs on its own while I sleep, so the guards are required. A pre-action command hook blocks destructive shell operations. A credential-egress guard blocks any outbound message that contains secret patterns. An ingest guard uses a local-LLM prompt-injection classifier to flag web content that tries to issue commands. Integrity monitoring on sensitive memory catches unauthorized changes to the persistent corpus, and automated write-rights verification flags any daemon that wrote outside its lane.

Governance is a written constitution with seven articles. It was independently and adversarially red-teamed the same night, hardened against 27 findings, and then ratified by me. Its floors (no auto-merge, no auto-send, no auto-spend, secrets never leave the host) can't be changed at runtime. Autonomous mode works inside those floors, and “never pause for approval” never applies to the gated classes.

Built is not armed. A new autonomous capability ships disabled, runs in shadow and builds a false-positive record. Only then do I arm it, with its kill-switch verified first.

Multi-model spine. The fleet mixes frontier models with local open-weights models that run on self-hosted inference at interactive speed. A model-agnostic spine is a stated design goal. Expensive frontier models handle judgment calls and adversarial verification, and the local model handles high-volume pre-filtering and classification. The system doesn't depend on any one provider staying available or affordable.

The security pipeline shows this tiering in practice. Cheap deterministic and local layers triage alerts automatically before anything reaches me, and the path is drill-tested end to end. Once, a mute rule looked right but did nothing. That lesson went into the permanent archive, and mutes are now verified differently.

Stack

Operator consoleAgent orchestrationLinux servicesMorning digestSelf-hosted infrastructureLocal LLM inferenceRedis

Result

The system has run continuously since early 2026 on a small self-hosted cluster. I manage it remotely: goals go in, a morning digest comes out. I don't need a laptop to issue tasks, and the digest keeps review under five minutes.

Scale figures like MTTR before and after, uptime percentage and cost savings in dollars are UNMEASURED, so I don't report them here. Here's what is measured. The corpus holds 406 persistent memory files with a 121-entry curated index, 1,564 work receipts, 160 engineering lessons, 50 installed skills and 21 learned beliefs that shape agent behavior (6 hard gates, 15 advisory). Five documented incidents each have a root-cause writeup and a lesson entry. Two of them: a host network setting whose side effect outlived the fix, and a scheduled maintenance job that caused fleet-wide false “network down” alarms. None of the five happened a second time.

The same infrastructure is also my live demo. What I show people is the exact system that does the overnight work, not a sanitized slide deck.

The right level of autonomy isn't the one that needs the least supervision. It's the one that earns exactly as much trust as its receipts justify.