WRITING · ESSAY 01 · 2026-10-25

The personal agentic operating system

A single operator can run a JARVIS-class life-and-work OS, if the agent is given real utilities rather than prompts. The OS is the integration layer, not the model.

← All essays

The OS is the integration layer, not the model

The thesis, stated up front: a single operator can run a JARVIS-class life-and-work OS, if the agent is given real utilities rather than prompts. The model is rented intelligence. The operating system is everything that makes it useful: the utilities it can call, the state it persists, the schedule it keeps, and the sensing that notices when any of it degrades.

I run one. It is not a demo, it is the thing that writes this essay's own website, sends my proposals, scans my inbox, and holds the architectural record for every system I own. It also fails in ways worth publishing, and one of those failures is below with its SQL.

The constraint came first

Most agent infrastructure is designed as if the host is free. Conveniently, the host is never free. The standard answer to "my agent needs to read a web page" is to ship a headless Chromium and put it in a container. That answer costs several hundred megabytes of image, a few hundred megabytes of RAM per instance, and a surprising amount of CPU, when the thing that actually needed to happen was extracting text.

I built the opposite way, because I had no choice. My agents run on a $20/year VPS (the invoice is a register entry, not a rounded story). No headless Chromium in the serving path. No Docker layer doing the work. Everything an agent needs to touch the outside world had to be a native binary or it did not exist.

That constraint turned out to be the most valuable design decision in the system. This essay is what it forced, what it cost, and what is still broken.

Why this matters more than it sounds

The industry pattern for agent projects is a wrapper: a prompt chain, a framework, and a container. It demos well and fails quietly. The failure modes are consistent, and they are not model failures:

  • Silent failure. An unmonitored run dies and nothing downstream knows.
  • No persistent state. Knowledge evaporates when the session ends.
  • Host drift. Hardcoded paths break when the environment moves.
  • No invariants. Nothing fails closed, so a bad run is discovered by its consequences.

The reference architecture for the fix is old, and that is the point: Stafford Beer's Viable System Model (policy, strategy, coordination, and operations as distinct systems) layered with IBM's MAPE-K autonomic loop (monitor, analyze, plan, execute, over shared knowledge). This is the actual architecture of the thing I run, not an analogy dressed in a citation. The system senses its own runtime health and halts its own actuation loops when sensing degrades. Whether it does that well is a question the telemetry section answers honestly.

What the system is today

Compiled from the filesystem and registries on 2026-10-25, with the command named next to every number so you can re-derive the ones that are public:

What Count Measured how
Governed system pools 25 arch stats, 2026-10-25
Architectural decisions / regression guards 271 / 211 same pass
Employees in the task-grid registry 167 employees.json, 2026-10-25
Public repositories (132 total) 67 GitHub GraphQL API, 2026-10-24
Native CLIs in ~/bin 44 directory count, 2026-10-25
sourcehound catalog 454 sources, 22 pools sourcehound catalog, 2026-10-25
Recorded cron executions (September runtime) 0 see the postmortem below

The September version of this table said 24 pools and 218 decisions. The system grew, the table was recompiled, and the old numbers are in the site's measurement register with the dates attached. One row did not grow: the execution record. It is the most important row in the table and it gets its own section.

Four strata: a governance cortex (the decisions, the linter, the registries), a swarm substrate (task state machine, employee contracts, a communication bus), ten-ish shared foundations (identity, strategy, research vault, content, site factory), and the ventures they graduate into. Governance is not documentation: decisions and regression guards are indexed in SQLite FTS5 and enforced by a linter, and every gate is proven by a fixture that fails on an injected violation.

The taxonomy: eight capability classes, not eight integrations

This is the decision that makes the rest of the system fit on one host, and it was made before any of the tools were written.

The utility layer is not organised by platform. It is organised by agent capability:

agentic-utility/
  memory/       delegation/   automation/   cogniton/
  internet/     skills/       content-creation/   social-media/

Eight classes. Everything an agent needs to be useful is an instance of one of them. Twitter, LinkedIn, Reddit, Discord, Telegram, Instagram, Threads, and Facebook are not eight products; they are eight implementations behind one social-media capability. Web access is one internet capability, not one integration per data source.

The consequence is architectural, not cosmetic:

  • One substrate serves every implementation. The CLIs share one runtime, one credential store, one output contract, one update path. The alternative, a separate stack per platform, is thirty runtimes, and that is what does not fit on a small VPS.
  • New surfaces are implementations, not architectures. Adding a platform adds a provider behind an existing capability. It does not add a process, a daemon, or a dependency tree.
  • The output contract is uniform. Every tool emits the same agent-readable format, which is why the TOON optimisation in sourcehound pays off across the whole fleet rather than in one tool.

The four problems the constraint created

1. Rendering, without a browser

Generating a slide or a carousel normally means launching a headless browser, driving a DOM, and screenshotting it. On a small VPS that is the most expensive thing in your stack, and it is pure overhead: you are paying for a general-purpose rendering engine to draw rectangles and text. deckmill embeds a Rust renderer instead. No Chromium dependency. 27,383 lines of first-party Rust and 203 static test attributes (both re-counted 2026-10-25, method in the register). The slide registry carries 46 entries, 38 live slide types and 8 retained as removed, and the register now prints exactly that, after a red-team pass caught it printing a figure the repository disproves. The correction is public in the register's reconciliation zone, which is the discipline this essay argues for applied to itself.

The interesting part is the accessibility gate. When you control the renderer you can refuse to emit a slide that fails WCAG-AA contrast, rather than discovering it in review. Refusing to produce a defective artifact is cheaper than reviewing one.

2. Browsing, without bundling a browser per task

The browser still has to exist for the tasks that genuinely need one. The design answer was to make it a fleet, not a library. browsefleet runs as a self-hosted stealth browser fleet exposing REST and CDP APIs to agents; cloakctl keeps one persistent browser per profile behind CLI verbs, plus a registry where agents compound reusable automations, distinguishing skills from workflows so a repeated sequence becomes a named capability instead of a re-derived prompt.

obscura-core is the library underneath: cookie management, a daemon, connection pooling, and a plugin system. Connection pooling is what makes this viable on a small host. The expensive thing is not the browser, it is the cold start, so the architecture is built to never pay it.

3. Intelligence at scale, without API keys

sourcehound is the intelligence gatherer: an MCP server that parses RSS, HTML, and JSON and normalises across sources. Its catalog, read from the running binary on 2026-10-25, holds 454 sources across 22 pools, 421 of them active. It exposes 23 tools, counted from the binary registry with sourcehound call --list, not from documentation. Two design choices matter:

  • Zero API keys. Every other gathering tool in this category is a paid API with a credit meter. Ours authenticates as little as possible and scrapes what it can, because a metered dependency is a hard cap on how much an autonomous loop can do. The comparison set (Tavily at $0.008 per credit, Firecrawl at $16 to $399 per month) is cheap per call and expensive per autonomous loop.
  • TOON output. Tool results are emitted in a token-optimised format rather than JSON, measured at 40 to 60 percent payload reduction. That is the difference between an agent that can afford to gather twenty sources and one that can afford eight.

It is a single static binary, roughly 7MB, holding roughly 5MB resident when idle.

4. Memory and models, without a cloud bill

operant is a terminal-native agent runtime built local-first: 7 workspace crates (the workspace consolidated from 18 in October; the manifest is the record), 390,981 lines of Rust under crates/ plus 4,381 vendored lines printed separately, 4,959 static test attributes, and a gate that ran 7,168 tests with zero failures at its pinned commit. llama.cpp integration, MCP, REPL, and TUI interfaces. Nothing leaves the machine.

Where a hosted model is unavoidable, a gateway sits in front of providers with quota-aware automatic fallback. Fallback is not a nicety here: on a system that runs unattended, a provider returning 429 at 03:00 must not be a terminal condition.

Governed execution: typed planning and the gates

The piece most agent stacks skip, and the piece my archetype readers ask about first, is how execution stays governed once the agents are autonomous. The answer is a contract layer the agents cannot route around.

Every system in the organism declares its structure in a typed manifest: what it is, which prefixes it owns, which services it offers and consumes, which sub-systems it pools. A linter validates the whole graph against those declarations on every pass. The declarations are not wiki pages; they are the input the tooling reads, so a system that lies about its structure fails validation rather than misleading the next agent that reads it.

On top of the declarations sit three enforcement patterns:

  • Decisions and regression guards as records. 271 architectural decisions and 211 regression guards, indexed and searchable, each one stating what was decided, why, and what would count as the decision being wrong. An agent proposing a change that contradicts a guard is stopped by the linter, not by a prompt asking it to please be careful.
  • Gates proven by fixtures. Every validation gate ships with a fixture harness that demonstrates the gate failing on an injected violation. A gate without a fixture is a hope, and hopes do not survive contact with an agent optimising around them. (Essay 7 is the postmortem of the time agents gamed a gate anyway, and what that taught me about gate design.)
  • Single-writer state. Relational state lives behind one writer with the schema owned by one system; every other consumer reads through a declared interface. The alternative, agents writing directly to shared databases, is how parallel sessions corrupt each other quietly.

The mechanism matters more than the specific tooling: typed contracts, executable enforcement, and state ownership are what let 167 registered employees work the same estate without standing on each other.

The part that is not working

The sensing layer. I traced it to root cause, and the story is worse than a miscalculation, so I am publishing the whole thing.

In September, the generated architecture report claimed 476 recorded cron executions. The runtime telemetry view, generated from the same filesystem at the same timestamp, reported 0 runs for all 24 pools. One of the two had to be lying.

It was the architecture report. Here is the query:

sqlite> SELECT COUNT(*) FROM executions;
0

~/.hermes/cron/executions.db existed, was 20,480 bytes, and contained an empty executions table. There were 92 cron jobs declared in the fleet. Not one execution had ever been recorded. The telemetry report was correct.

The architecture report was wrong because of a default value:

# compiler.py
"total_cron_executions": gen.get("matrix_summary", {})
                           .get("fleet_metrics", {})
                           .get("total_cron_executions", 476),

Because the database was empty, the matrix never produced the key, so the fallback fired every single time and printed 476. The constant appeared in three places in that compiler, and again in the executive deck.

This is the failure mode worth dwelling on. A missing metric fails visibly. A defaulted metric reports a plausible false one, and only contradicts itself when a sibling report reads the same data honestly. If the telemetry view had not also been generated, the fabricated number would have been the only number.

The fix list was ordered and unglamorous: delete the 476 default so a missing metric renders as missing; wire the writer so each job inserts a row; stop swallowing exceptions in the telemetry reader; and add a consistency gate that refuses to emit an execution count contradicting the telemetry view. Only the fourth one is interesting, and it is the only one that generalises.

Then the honest epilogue. The runtime those 92 jobs belonged to was decommissioned in the October reorganization, replaced by a single-scheduler organization where routines are the only source of automated firing and a fail-closed pre-tick smoke gate blocks agent spawns when the health check fails. The register on this site still prints the zero, with the decommission note attached, because retiring the row would retire the lesson with it. What I will not do is print a new, larger number for the replacement runtime until its own execution record has been measured and dated. This essay's own measure of the current state is the one above: the scheduling is now real, the record-keeping is the part I owe the next version of this table.

Secondary evidence pointed the same direction in September: 62 smoke BLOCK verdicts, 13 on the freelance pipeline and 11 on the career pipeline, with six fixer patterns that re-occurred after being fixed. A fixer pattern that returns means the system detected a failure, repaired it, and then failed identically again. That is symptom healing, which is what you get when the sensing layer cannot tell you whether the healing worked. The healer employees you can see in the current registry are the descendants of that finding.

I am publishing this because the alternative is worse. An agent infrastructure project that reports only its architecture is a project you cannot evaluate. The number that matters is not 25 governed pools. It is whether the thing notices its own degradation, and in September it did not; it reported a constant instead.

The constraint is the argument

There is a version of this essay that is about how clever the architecture is. That version is not worth reading, so here is the actual reason the constraint mattered.

Agent infrastructure that requires a cloud budget means automation accrues to whoever already has capital. Every design choice above (no headless Chromium, no container layer, a 7MB static binary, a memory engine that runs locally, provider fallback instead of a metered dependency) is a decision about who can afford to own their own leverage.

That is not a slogan; it is a memory figure. A stack that needs several hundred megabytes per task to read a web page is a stack that only organisations with infrastructure budgets can operate. A stack that reads the same page for a few megabytes of resident memory is a stack one person can run on hardware they already own.

I am not claiming this dissolves anything by itself. Infrastructural access is a necessary condition, not a sufficient one, and building tools is not the same as building a society. But the direction of the constraint matters, and it is a decision you make once, in the architecture, when it is still cheap to make.

What I would tell you if you are building this

The decision I would reverse is one I already did reverse, and it cost me months: I built a custom memory infrastructure, tdg-rust, 648 test attributes behind it as measured last week, because I wanted retrieval that was typed, exact, and mine. The design assumption was that retrieval quality is a data-structure problem. In practice it never met expectations against the workloads the agent actually runs, and the system sat between the agent and its context.

I removed it. The replacement is agent-memory, and the honest label is that the decision was qualitative at replacement time, latency and recall against expectation, not a captured benchmark, so I state it as that. The number that does exist is the tool-surface audit (2026-08-26): a full-load session carries roughly 21.8k tokens of schema surface; the replacement's server registers 7 tools at roughly 121 tokens per tool, the audit's named model to follow. The audit's fleet-wide tool total is withdrawn in the register (R18): one member server alone outgrew it, and an aggregate that cannot survive its own members is not a measurement. The thing I spent months building was also, indirectly, the thing teaching me what the budget actually was.

The lesson I would hand you: refinement reversals are cheap and frequent (sourcehound went from news-scraping to a total web-search and browser-navigation interface without drama). A true reversal is the one that discards built work. When the measurement, or the honest absence of one, says the substrate is wrong, discard it early. The months you spent are sunk; the sessions it slows down are not.

Where the OS actually shows up

An operating system is demonstrated by what it runs, not by what it contains. From the registry (generated from every pool's manifest, 2026-10-25):

Pipeline Pool Declared crons
Job pipeline career-pipeline 15
Freelance pipeline freelance-agency 15
Content creation brand-integrating + brand-polarizing 4
Community management community-loo 2
Agent command center task-grid 3

Each pipeline is a five-step lean-manufacturing cycle, not a chatbot: the job pipeline runs scan-inbox, score-lead, match-ats, submit, log; the freelance pipeline runs scan-platforms, match, draft-proposal, send, log; content runs plan, draft, qa, schedule, report; community runs read-channel, synthesize, draft, deliver, log; the command center runs notice intake, route, ack, assign, log.

The one integration that took longest to get right was not a platform; it was the governance layer. The knowledge-base format, the per-system CLI utilities, and linter-level validation of the documentation took months of iteration: an architecture CLI and design system that enforce rules and decisions so that agents working on any system cannot make outlandish deviations. Second longest: social-forge, the multi-platform agent-interface substrate (LinkedIn, Facebook, Instagram, Reddit, WhatsApp, Telegram, email, plus content-creation utilities), driven to production-grade robustness. The biggest friction point was handing everything to autonomous agents while enforcing architectural and operational constraints on their interaction surface. That friction is why the gates exist in the form they do.

If you take one thing from this essay, take the integration-layer claim and test it against your own stack: list what your agent can actually do when the model is offline. Whatever survives that list is your operating system. Everything else was the model wearing a costume.

The audience contract this was written under

Written for

  • Aspiring Agentic Builder
  • Deployment-First Architect

Has to hit

  • Before and after refactors with code
  • How working engineers actually structure agent systems
  • Repo walkthroughs with architecture rationale
  • MCP infrastructure deep dives

Rejected if it

  • Courses sold as shortcuts
  • Gatekeeping
  • Motivational fluff without technical meat
  • Framework-of-the-week hype threads

Figures in this essay: 8, each linked inline to the measurement record with its method and date.