The axiomatic layer. The Agency Paradox, AgentVector, the Laws, and the architecture that makes autonomous systems governable — not just capable.
Discipline alone is insufficient. The question is not whether the human is attentive enough. The question is whether the architecture enforces authority when the human is not watching.
The question of command is not a behavioral question. It is an architectural one.
The agent acts beyond its declared domain, one small step at a time, until the boundary no longer exists.
The system that was reviewed is no longer the system that is running. Changes accumulate without governance awareness.
A capability that was once constrained is quietly re-enabled by a model update, dependency change, or prompt mutation.
The agent acquires new tool integrations faster than governance can evaluate them. Each is approved; the surface area is not.
Ten actions, each within scope, combine into a pattern that no single approval anticipated.
The composition problem: Ten actions, each individually within scope, may collectively represent a pattern no single approval would have sanctioned.
Between the deterministic Laws and the stochastic agent sits the Stochastic Gap — the space where probabilistic reasoning meets deterministic authority. AgentVector bridges this gap with a kernel that compiles Laws into enforceable governance.
The state is the single source of truth. No hidden channels, no side-state. What the state declares is what the system knows.
Pure functions that take current state and an action, return new state or rejection. No side effects. No non-determinism. Replay-safe.
The agent proposes. The reducer decides. The agent never touches state directly. Governance is not advisory — it is the only path.
The Steward writes the Laws. The Kernel compiles them. The Agent obeys them. The Principal observes everything.Read the full Codex →
From philosophical foundation to runtime verdict, every layer is traceable. The proof chain is the architecture.
Philosophical Foundation ↓ "Who commands autonomous systems?" Constitutional Layer ↓ The Agency Paradox → Nine Properties Specification Layer ↓ Law 0 (Scope) … Law 8 (Composition) … Law 10 (Reserved) Kernel Layer ↓ SwiftVector · TSVector · RustVector Governance Layer ↓ ClawLaw · FlightLaw · DispatchLaw · ChronicleLaw Module Layer ↓ Domain-specific reducers · Policy evaluators Verdict ↓ .allow · .deny · .escalate Coherence Verification ✓ Deterministic · Composable · Auditable
The agent cannot modify, bypass, or disable the governance layer.
Same action, same policy, same session state produces the same verdict, always.
When governance state is uncertain, the default is denial.
Full evaluation trace, not just the verdict.
Session-level state as input to deterministic evaluation.
Same authority model regardless of where the agent runs.
Full operational picture reconstructable from governance evidence alone.
Staleness is a governance failure, not a minor degradation.
An explicit, finite action surface governance can evaluate.
Eleven Laws in four groups. Each Law is a pure function: given a state and an action, it returns a verdict. No ambiguity. No discretion. No escape.
The agent shall not act outside its declared domain.
The agent shall interpret ambiguity through its declared domain lens.
The agent shall only use tools registered in its manifest.
The agent shall declare its identity, scope, and limitations on request.
The agent shall escalate to the principal when confidence is below threshold.
The principal may override any agent decision. The override is logged.
Every verdict shall include the evaluation trace that produced it.
The agent shall not act on stale knowledge without disclosure.
Session-level action patterns shall be evaluated, not just individual actions.
Reserved for future constitutional extension.
Reserved for future constitutional extension.
Three runtime implementations. Same Laws, same reducer contract, different substrates. The kernel is not a library — it is the governance runtime.
The primary enforcement kernel. Actor isolation, Apple Silicon native, deterministic reducers. The kernel that compiles the Laws into executable governance.
Node.js runtime for web-facing governance. Same Laws, same reducer pattern, different substrate. Integration-first for existing toolchains.
Cross-platform enforcement at the edge. Zero-cost abstractions, no runtime, deterministic by construction. Where governance meets hardware constraints.
The principal redefined: The pilot does not fly the aircraft by moving each control surface. The pilot commands the flight control system, which moves the surfaces. The principal does not govern the agent by approving each action. The principal commands the governance kernel, which enforces the Laws.
Governing Intelligence is the constitutional root. Everything else is a jurisdiction.