Isagawa turns repeatable workflows into governed agent harnesses. The kernel enforces execution, the domain-spec factory builds vertical packs, and the backlog pipeline turns intent into validated work.
Each step enforces contracts, validates gates, and records lessons for the next run.
Not configuration. Not templates. Specification-driven agent harnesses that learn from failures.
The foundation: governance/runtime loop that all subsequent capabilities inherit. Hooks. Commands. Protocol. The framework that runs domain specs.
The kernel is a set of interlocking mechanisms, engineered through iterative specification and testing. 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. The kernel blocks normal agent tool use when required protocol, validation, or learning steps are incomplete. Not optional. Not negotiable.
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.
Framework Architecture
Kernel (governance/runtime loop)
↓ runs
Domain Setup (bootstrapping/self-build loop)
↓ compiles
Domain Spec + Repo Context (installable vertical plugins)
↓ into
Protocol + Commands + Gates + Lessons
↓ enabling
Governed Agent Execution
SDD architecture: the kernel governs execution, the domain-spec factory compiles specifications into harnesses, and together they bootstrap each new capability.
The kernel governs execution. The domain-spec factory compiles specifications into structured agents. The result: 30+ AI agents, a 12-step compilation pipeline, and governed development environments that inherit kernel management from creation.
Harnesses, agents, and domain specs compiled from specifications. Each one teaches the system a new field: QA, compliance, healthcare, DevOps, creative production, real estate.
A pipeline that compiles specifications into structured harnesses. 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 produces new capabilities. Each capability extends what's possible next.
New skills, new commands, new workflows are produced and integrated. The system expands its own capabilities. Each new capability becomes part of the system, enabling even more capabilities.
Every capability begins as a specification. The backlog captures specifications and structures them for execution. 130+ items logged, each one a starting point for autonomous production.
One command decomposes intent into tasks and executes them. 90+ completed pipelines across 50+ repos. Autonomous for deterministic execution; HITL for approvals, failures, and judgment points.
Produced Harnesses
Fraud Detection Platform · Healthcare QA · SSH Compliance Testing
Produced Skills
Website Cloner · Attestation Pipeline · Production Test Framework · Autonomous Cycling
and more. Each one produced by the same loop.
You are looking at the output.
This page is built by the spec-driven architecture it describes. The kernel provided governance. The backlog captured specifications. The pipeline decomposed and built. The attestation signed the work. Verifiable via Rekor timestamps below.
The loop is the core runtime architecture.
Every pipeline run is signed with Sigstore and logged to Rekor. These are real attestation bundles. Verify them yourself.