AgentVector wraps stochastic models inside deterministic control loops, then applies a Codex of composable laws and jurisdictions for permissioning, audit trails, and reproducible behavior.
→ State, not prompts, must be the authority
AgentVector is an architectural pattern that separates stochastic AI reasoning from deterministic system control. By treating AI agents as advisory components within a controlled loop, we achieve reproducibility, auditability, and safety in complex multi-agent systems.
Wrap stochastic AI agents in predictable, reproducible control flows. Every state transition is explicit and auditable.
Agents reason and suggest actions. Reducers hold authority and transform state. Clear boundaries prevent unauthorized behavior.
Every action, every state transition is logged. Replay any execution path for debugging, compliance, or analysis.
Designed for autonomous systems where failure is not acceptable. Deterministic behavior enables formal verification and testing.
Canonical papers and ongoing writing around AgentVector.
Why giving AI agents less freedom makes them more useful. The counterintuitive case for architectural constraints.
PublishedThe constitutional framework: composable Laws, multi-kernel enforcement, and domain-specific governance for governed autonomy.
Interactive overview of the AgentVector framework — Codex, Laws, enforcement kernels, conformance tests, and jurisdictions.
Governance must run where the agent runs. The technical case for deterministic enforcement at the point of action — in any language, on any runtime.
Why the reference implementation is built in Swift. Technical specification for deterministic AI control.
How JSON fixtures prove enforcement equivalence across kernels. One Codex, multiple languages, verifiable agreement.
Directing AI agents as a practiced discipline. Scoping work, enforcing invariants, and building the judgment to know when to intervene.
The governance layer beneath every governed agent. Budgets, sandboxes, jurisdictions, and the Laws that agents cannot override.
Observability for the agentic stack. Event instrumentation, governance dashboards, and the DevOps discipline for autonomous systems.
AgentVector shines in scenarios where reliability, auditability, and safety are non-negotiable.
Deterministic enforcement for autonomous desktop agents. ClawLaw constrains actions, budgets, and permissions at the moment of execution — not after the fact. The first AgentVector jurisdiction, built on the SwiftVector kernel.
Drones, robotics, and aviation systems require governance where failure is not acceptable. FlightLaw applies AgentVector's deterministic control loops to environments that demand formal verification and real-time enforcement.
Generate consistent, branching narratives over thousands of interactions. ChronicleLaw ensures story state remains coherent, every plot development is traceable, and no agent action can corrupt the canonical timeline.
AgentVector is composable. Select the laws your domain requires, enforce them through a kernel that fits your runtime, and define the governance boundaries your agents need. The Codex is the contract — the jurisdiction is yours to build.
Where the Law applies. Jurisdictions compose governance. Applications operate under it.
Desktop Agents
Governed autonomy for desktop agents. Filesystem containment, budget circuit breakers, and authorization gates.
The Steward interface for ClawLaw-governed autonomous agents — an operational command layer that surfaces the approval queue, budget enforcement levels, sprint-scoped work authorization, and the complete audit trail from any browser. Watch Station reads ClawLaw state and relays Principal decisions back to it; it never reimplements governance logic. The agent proposes actions, ClawLaw suspends what requires approval, and Watch Station gives the Principal a single interface to approve, reject, or review — visually, auditably, and without surrendering control. Runs as a launchd service on Apple Silicon, independent of the agent it governs.
Autonomous Aviation
Deterministic safety for autonomous flight. Geofencing, pre-flight validation, budget management, and risk-tiered approval.
The governed single-agent flight stack. GeoVector closes the stochastic gap between spatial ML inference and the geofence — Sentinel gates every MAVLink frame at the autopilot wire with a pure-function Swift rule engine and Rust proxy. One product, two components in series, connected across the PositionAuthorityInterface.
Governed multi-agent ISR in comms-denied environments. Same FlightLaw laws and CommitVector pattern, different operational domain — inter-agent cue authority across a swarm, not a single autopilot wire. On-device governance kernel with three-tier authority degradation.
Narrative AI
Human authorship verification in AI-assisted storytelling. Protects narrative coherence and world-fact integrity.
SwiftVector applied to interactive narrative — where the Bond Principle originated. Game mechanics align system behavior to produce specific outcomes, the same pattern that governance systems use to align agent behavior with mission parameters.
AI-assisted content creation governed by the same constitutional pattern. The agent drafts freely; the reducer enforces editorial boundaries, style constraints, and publication gates.