Governed agent runtime with hook-enforced execution.

The Problem

Agents drift. Forget. Skip steps. Prompts don't fix it.

Mid-task they forget what they were doing. They skip steps they read minutes ago. They rationalize shortcuts as "more efficient." The model has already proven it will read the instruction, agree, and then violate it. Telling it harder doesn't work. Asking nicely doesn't work. The fix has to be structural.

• How do you stop an agent from skipping a checkpoint it just read about?
• How do you make the system catch its own failures, even when the agent thinks it didn't fail?
• How do you keep behavior consistent across hour-long sessions and context compression?

The Loop

Every session runs the same loop. No step can be skipped.

session-start, anchor, work, complete. The same cycle, every session. Anchors fire every N actions. Failures trigger a mandatory learn step. State survives restarts. Context survives compression. The loop itself is hook-enforced. Specific rules within it land in one of two tiers: hooks where they can, protocol re-read at every anchor where they can't.

session-start -> anchor -> WORK -----------------> complete
                   ^         |                       ^
                   `-- every 10 actions <-----------'
                             |
                   failure? -> fix -> learn (MANDATORY)

Domain Setup

Configuration from code structure.

The domain-setup command scans your repository structure, discovers file patterns, naming conventions, and existing code organization, then generates an initial protocol configuration. This configuration becomes the baseline for governance. Optional domain specs layer industry-specific knowledge on top of the discovered patterns.

Task Execution

From intent to verified completion.

The execute-pipeline command transforms written intent into executable tasks. The task-builder decomposes intent into atomic steps, each with a single action and measurable acceptance criteria. Each step includes a gate contract that defines preconditions and success criteria. The run-task.sh executor cycles through tasks with retry logic, state persistence, and failure recording.

Autonomous Cycling

Task queues across sessions.

The autonomous-cycle command executes task queues sequentially while maintaining full governance enforcement. State persists between sessions completed tasks are tracked, failed tasks are logged with failure details, and skipped tasks include audit records. The agent picks up exactly where it left off: what task failed, why, and what was attempted.

SDD Architecture

Four moving parts. One governance layer.

Each component addresses a specific failure mode. Together they reduce the surface area where the agent must be trusted to follow text it has already proven it will violate.

Design Decision

Two-tier governance. Mechanical and behavioral.

Hooks alone are too rigid. Protocol alone is too soft. Both are necessary. The lesson file is exactly the seam between them: every entry is either already a hook or a candidate to become one.

Hooks alone would require encoding every conceivable rule in code: impossible for a self-improving system. Protocol alone would rely on the agent following text it has already proven it will violate. Together: hooks for the rules you can enforce mechanically, protocol for the rules you can't.

Specialized Skills

Purpose-built execution patterns.

Beyond core governance, specialized skills extend the kernel for domain-specific and operational use cases. Each skill encodes patterns, workflows, and conventions for a specific capability. All skills run under kernel governance the enforcement loop applies regardless of what the skill does.

Cross-Session Persistence

State that survives restarts.

Multiple state files work together to preserve execution context across process restarts. Session state holds anchor status and action counts. Workflow state tracks completed tasks and current task. Intent chains hash user input and generated specifications. Anchor logs record violations. Lesson files document learned rules. Together, they enable deterministic resumption from exactly where execution was interrupted.

Results

Numbers from the workspace this page was built in. Receipts in the linked repos.

Produced Harnesses

Same kernel. Different stacks.

Each harness below demonstrates the kernel applied to a specific domain. All use the same governance layer and execution model with domain-specific patterns and conventions encoded in optional domain specs.

Receipts

The system writes down its own failures.

An anchor catches a self-detected violation. The intent chain hashes the user's words. A recorded lesson flags a candidate for mechanical enforcement after recurrence, if the rule can be hooked at all. All three are append-only artifacts from this workspace.

{
  "anchor_timestamp": "2026-06-08T06:45:00Z",
  "actions_count": 48,
  "violations_found": 1,
  "violation_details": [
    "Backlog 129 created via direct intent.py call,
     bypassing /kernel/backlog skill."
  ],
  "needs_learn_set": true
}

{
  "rev": 1,
  "timestamp": "2026-06-08T07:24:57+00:00",
  "raw_input_hash":     "0c43483511fb6ee241b34fc58c294751...",
  "backlog_hash_after": "6f9ebac571cb3369ee518f1d04432458..."
}

## 2026-06-08 Bypassed /kernel/backlog
- Root cause: batched "yes" trigger, agent
  optimized middle item for speed
- Recurrence: 2nd time recorded
  (first: 2026-04-25 with backlog 047)
- Escalation: mechanical enforcement via
  PreToolUse hook now overdue

Full attestation chain at /attestation.html.

Who This Is For