Agentic control kernel

Agentic Control Kernel

A purely knowledge-based metalayer that unifies six subsystems into a single installable skill for any project:

Layer	Source / Crates	Role
Governance	control-metalayer-loop	Setpoints, sensors, gates, policy, profiles
Improvement	autoany_core + autoany-aios + autoany-lago	EGRI microkernel, Arcan execution, Lago ledger
Orchestration	symphony-orchestrator + symphony-arcan	Poll/dispatch/worker/reconcile via Arcan HTTP
Runtime	Life (arcan, lago, autonomic, praxis, spaces)	Agent sessions, event journal, homeostasis, networking
Protocol	aios-protocol	Canonical types — shared vocabulary across all crates
Episodic Memory	knowledge-graph-memory	Conversation logs -> Obsidian bridge
Consciousness	agent-consciousness	Three-substrate persistent context
QA/Actuation	gstack	Headless browser, workflow skills
Control Kernel	this skill	Plant interface, safety shields, typed schemas, multi-rate hierarchy

Core Law

Do not grant an agent more mutation freedom than your evaluator can reliably judge. In control terms: do not let the LLM's action space exceed what your runtime monitors, safety filters, and evaluators can certify.

Quick Start

1. Bootstrap a project

python3 scripts/control_kernel_init.py <repo-path> [--profile governed] [--runtime arcan] [--ledger lago]

This installs into the target repo:

• .control/policy.yaml — control-systems-aware setpoints
• schemas/ — state, action, trace, evaluator JSON schemas
• METALAYER.md — control loop definition with plant/shield/estimator sections
• Harness gates wired to make smoke, make check, make control-audit

2. Define the plant interface

Edit .control/plant.yaml with typed state and action schemas for your system. See references/plant-interface.md for the full API spec.

3. Wire safety shields

See references/safety-shields.md for CBF-QP patterns, policy gates, and containment invariants.

4. Set up EGRI for controller improvement

Use the problem-spec template in assets/templates/problem-spec.control.yaml to define an autoany loop over your controller artifacts. See references/egri-for-controllers.md.

Architecture Overview

The LLM emits typed control directives θ_t — not raw actuations u_t. Deterministic controller modules execute, safety shields filter, and the runtime logs traces to an append-only ledger.

Plant → observe() → Runtime → update estimator → b_t
  → LLM Agent: request decision(b_t) → θ_t (typed directive)
  → Controller: propose(b_t, θ_t) → proposed u_t
  → Safety Shield: filter(u_t, b_t) → safe u_t + certificate
  → Plant: apply(safe u_t) → result
  → Evaluator/Ledger: append trace + score

See references/architecture.md for the full 5-layer diagram.

Multi-Rate Hierarchy

Loop	Cadence	LLM here?	What runs
Servo	ms	No	PID, state feedback, deterministic
Constrained execution	10-100ms	No (param updates only)	MPC/CBF-QP solvers
Supervisory planning	seconds	Yes	Goal setting, mode switching, tool selection
Auto-tuning (EGRI)	minutes-days	Yes	Controller synthesis, model learning

See references/multi-rate-hierarchy.md.

LLM Roles in the Control Stack

Role	Outputs	When to use
Supervisory controller	setpoints, mode switches, constraints	Default — long-horizon reasoning
Meta-controller	tool/module selection, identification triggers	Modular systems with multiple controllers
Controller synthesizer	code, configs, tests	Offline — gated by harness CI
EGRI loop compiler	problem-spec, evaluator design, promotion rules	Continuous improvement cycles

See references/architecture.md for the full role table.

Reference Guide

• architecture.md — 5-layer stack, realized crate graph, control-flow diagram, component mapping
• integration-map.md — Adapter crate boundary map, configuration, direction rule
• plant-interface.md — Plant/Estimator/Controller/Shield/Evaluator API specs
• safety-shields.md — CBF-QP, policy gates, containment, failure modes
• multi-rate-hierarchy.md — Loop rates, LLM placement, heuristics
• world-models.md — Koopman, DeePC, digital twins, learned dynamics
• egri-for-controllers.md — Autoany applied to controller optimization
• orchestration-patterns.md — Symphony daemon patterns for multi-agent dispatch
• consciousness-stack.md — Memory/knowledge/episodic integration
• failure-modes.md — Mitigations catalog for LLM-in-the-loop control
• deep-research-report.md — Original research report and project plan: formal control theory, literature survey, prototype roadmap

Schemas

JSON Schemas in schemas/ enforce typed interfaces:

• state.schema.json — Plant/belief state
• action.schema.json — Control directives (θ_t)
• trace.schema.json — Ledger entries (autoany-compatible)
• evaluator.schema.json — Score vectors, promotion decisions
• egri-event.schema.json — EGRI trial events for Lago persistence via EventKind::Custom

Existing Skill Dependencies

This skill synthesizes and references (does not duplicate) these existing skills:

• control-metalayer-loop — Use for .control/ bootstrapping and governance primitives
• autoany — EGRI loop execution via autoany-aios (Arcan sessions) and autoany-lago (Lago ledger)
• symphony — Orchestration dispatch via symphony-arcan (Arcan HTTP runtime)
• life — arcan (agent sessions), lago (event journal), autonomic (homeostasis), spaces (networking)
• aios-protocol — Canonical types shared across all adapter crates
• agent-consciousness — Use for consciousness stack setup
• knowledge-graph-memory — Use for conversation bridge to Obsidian
• gstack — Use for QA actuation via headless browser