You describe intent in natural language. The factory produces structured artifacts (including new capabilities) under runtime governance. Those capabilities become part of the factory. The loop closes.
A minimal kernel (hooks, commands, and a protocol) that governs everything built after it.
The kernel is a set of interlocking mechanisms, produced by conversation. Together they make governance a property of the system, not a layer on top of it. Every action the factory takes passes through these gates. They cannot be bypassed. Not by the agent, not by prompt engineering, not by editing state files.
Every N actions (configurable), the system forces a full protocol re-read. A UUID token proves the agent actually re-centered. It cannot fake compliance by flipping a boolean.
A hook at the tool-call boundary that blocks writes until prerequisites are met. Missing a lesson? Blocked. Skipped an anchor? Blocked. The agent must fix the root cause to proceed.
Every failure records a lesson. The protocol updates mechanically. The same mistake becomes impossible. Not because the agent remembers, but because the system enforces.
Start, anchor, work, complete. The same loop, every session. State survives restarts. Context survives compression. The system picks up where it left off.
The kernel produced everything it now uses to operate: specs, a factory, workspaces.
None of this was hand-coded. The kernel managed conversations that produced domain specifications. Those specifications taught the system new fields. A factory pipeline emerged to compile natural language into structured specs automatically. Workspaces followed. Complete development environments that inherit kernel management from birth.
Domain specifications produced from conversational intent. Each one teaches the system a new field: QA, healthcare, DevOps, compliance, real estate, creative production.
A pipeline that compiles natural language into structured domain specs. The factory itself was produced by the kernel. The system built its own compiler.
Complete development environments with hooks, commands, and protocols. Each workspace inherits kernel governance. Each one can produce new capabilities the kernel has never seen.
The system now produces new capabilities from conversation. Capabilities that extend what future conversations can produce.
This is where the loop becomes visible. New skills, new commands, new workflows, all produced by the system, all becoming part of the system. Each new capability extends the range of what a single conversation can build next. The factory is not just producing outputs. It is producing itself.
Every capability begins as a sentence. The backlog captures raw conversational intent and structures it for execution. 74+ items logged, each one a starting point for autonomous production.
One command decomposes intent into tasks and executes them. 24 attested pipelines, 800+ tasks across 9 repos. No human intervention between start and finish.
Website Cloner · Attestation Pipeline · Production Test Framework · Autonomous Cycling · Fraud Detection Platform · Healthcare QA · SSH Compliance Testing
and more. Each one produced by the same loop.
You are looking at the output.
This page was built by the system it describes. The kernel governed. The backlog captured intent. The pipeline decomposed and built. The attestation signed the work. Three pipelines, 55 tasks, under two hours. The Rekor timestamps below prove it. Every section you just scrolled through was produced from conversational intent, including this one.
The loop is not a metaphor. It is the architecture.
Every pipeline run is signed with Sigstore and logged to Rekor. These are real attestation bundles. Verify them yourself.