11 Failures That Built an OS

Programs before Unix allocated memory directly. When a program crashed, memory leaked. No garbage collector. No process table tracking ownership.

GC daemon with memory pressure monitoring. Phase-scoped cleanup (kill -PGID pattern). Hierarchical resource ownership: Goal → Phase → Resource. Shell auto-detection registers spawned containers. Memory limits on all spawned processes.

Daemons before init/systemd: if a background process died, nobody restarted it. No watchdog. No health checks.

DomainDaemons that outlive the agent. Service lifecycle: deploy → monitor → restart → alert. Like systemd for AI agents. Two-phase gating: cheap health check first, LLM only when needed.

Programs before shared filesystems: every program had its own data format, its own storage. No way to share knowledge between processes.

TheLoom — three-layer persistent memory. Agents save SKILL.md files. Next agent reads the skill first. 5K tokens instead of 200K. 40x cheaper. The LLM reads markdown directly — no database, no indexing.

Programs returning exit code 0 when they segfault. No distinction between "I succeeded" and "I think I succeeded."

Three-tier verification: auto (shell check), ask_user (human confirms), none (honest yellow). Smart diagnosis rewrites bad verify commands. Evidence-based: if verify fails but processes are running, investigate before declaring failure.

Retry without backoff. No state tracking. No escalation path.

Demand lifecycle with states: active → attempting → escalated → resolved. Exponential backoff (1min, 2min, 4min...). Auto-escalation to user after 6 failed attempts. 5-pattern stuck detector (from OpenHands research): repeating tool calls, identical outputs, error-only loops, ping-pong oscillation.

Busy-waiting before interrupts. The CPU spins checking "anything new?" millions of times per second instead of sleeping until an event fires.

Two-phase gating. fast_check() is cheap (HTTP/API, zero LLM). Only if needs_attention=true does the expensive LLM tick fire. Sleep tiers: active (30s), idle (5min), dormant (1hr). $0.10/day instead of $86/day.

Programs before ulimit and cgroups: one runaway process could consume all system resources with no limit.

Per-agent token budgets (50K default). Session compaction. Observation masking (strip verbose tool output). Dynamic tool pruning (only show relevant tools per command). Cost-aware model routing (Haiku for diagnosis, Sonnet for planning). 200K → 5K for repeated tasks.

You can't bolt process management onto a framework. You can't add lifecycle to function calls. You need a fundamentally different architecture: an operating system where agents are the unit of execution, not functions.

Unit tests are necessary but wildly insufficient for agentic systems. The OS now requires E2E scenario testing: deploy in Docker, send real commands via Playwright, verify the service actually works. If you can't curl it, it's not deployed.

Complete rewrite: evolution is now demand-driven. No demands = no token burn. DemandSolver uses LLM reasoning: reads the codebase, reads the environment, reads past fixes, then decides what to build. MetaEvolver (random mutation) disabled. Only real user failures trigger evolution.

Evolution without accountability is waste. Every evolved artifact must have a caller. Every cycle must address a real demand. The evolution engine itself had to evolve — from random paper scanning to demand-driven problem solving.

Dead infrastructure is worse than no infrastructure. It creates the illusion of capability. Every component must have a CALLER. Audit: trace from user action → event → component → persistence. If any link is missing, it's dead code. Delete it.

Deleted SQLite stores entirely. Replaced with .opensculpt/constraints.md and .opensculpt/resolutions.md — plain text the LLM reads directly. The LLM IS the search engine. No indexes, no queries, no cosine similarity. Wired actual WRITING: pre-flight failures write constraints. Successful retries write resolutions. Now the OS actually learns.

An agentic OS powered by LLMs should store knowledge as text the LLM can read — not as database rows that need a query layer. .md files beat SQLite when the reader is an LLM.