State, not prompts, must be the authority.
A Rust proxy intercepts every MAVLink frame at wire speed before it reaches the autopilot. A Swift rule engine evaluates it against declared governance laws and issues a typed verdict. Neither the AI module nor the autopilot know Sentinel exists.
The AgentVector pattern separates stochastic intelligence from deterministic governance. AI agents observe state and generate proposals as typed Actions. Laws evaluate deterministically. Principals authorize at risk thresholds. Reducers transition state as pure functions. The audit trail records everything.
Agents observe state (read-only) and generate proposals as typed Actions. They never mutate state directly and never bypass the reducer.
Laws are constitutional constraints. They validate preconditions, enforce invariants, and gate authorization. FlightLaw violations always take precedence.
Reducers are pure functions. Same inputs always produce same outputs. No side effects, no I/O, no randomness. Invalid actions return unchanged state.
Every dispatched action is recorded. State hashes computed before and after. Source attribution included. Replay produces identical results.
Every architectural decision traces to one of three product outcomes. The architecture is not the product — it is the mechanism that makes the product trustworthy.
The operator must trust the system enough to authorize missions without micromanaging. Deterministic law evaluation, transparent decision surfacing, and replayable audit trails build this trust architecturally.
Every decision must be provable to a regulator, insurer, or commander after the fact. Hash-chained audit trails, tamper-evident logging, and deterministic replay provide the evidence chain that compliance demands.
New jurisdictions must inherit safety guarantees without reimplementing them. FlightLaw provides the universal safety kernel. Jurisdictions compose domain laws on top. The canvas plugin pattern keeps the interface extensible without exposing governance internals.
Every jurisdiction inherits FlightLaw. These nine laws (0–8) are evaluated before every state transition. FlightLaw violations always take precedence over jurisdiction-specific laws.
The AgentVector Codex defines the full Law registry (0–10). FlightLaw composes Laws 0–8 as its constitutional foundation. Jurisdiction-specific laws (EvidenceLaw, GridLaw, EMCONLaw, etc.) extend the kernel for each domain.
System boundary enforcement. Defines the operational envelope. EMCON boundary in ISR jurisdictions.
Principal authentication. Verifies the authorized human decision-maker before any mission state transition.
Environmental pre-flight gate. WeatherKit evaluation against operational thresholds. No override without principal authorization.
Telemetry quality, GPS lock, IMU calibration. The system must observe itself accurately before it can act.
Battery, compute, and link budget enforcement. Operations cannot exceed available resources. RTH reserve enforced.
Data classification at the state level. Active in ISRLaw jurisdictions. Determines handling, storage, and transmission constraints.
Authority contracts when comms degrade. Autonomy envelope contracts — never expands. Deterministic fallback chain.
Geofence, altitude ceiling, and no-fly zone enforcement. Corridor locked at mission authorization. Violations trigger immediate response.
These are not aspirational design goals. They are architectural constraints enforced at compile time and verified by determinism tests. Violations are build failures.
Same inputs always produce same outputs. No side effects, no I/O, no randomness inside reducers. No Date(), no UUID(), no .random(). Dependencies injected through protocols.
State types are value types. All properties are let, not var. Updates create new instances via .with() methods. State conforms to Equatable, Codable, Sendable.
All state changes go through typed actions. Actions are enums with associated values. Actions conform to Equatable, Codable, Sendable. No stringly-typed systems.
Every state transition is recorded in an append-only log. Each entry contains a SHA256 hash that chains to the next entry. Breaking the chain is detectable. The audit trail is the product.
Routine state transitions within established operational parameters. No principal interaction required.
Elevated risk transitions. Principal notified. Approval window with configurable timeout. Default action on expiry.
Critical transitions. Principal must explicitly authorize. No timeout, no default. The system waits.
GeoVector is the open source Apple-native geospatial application layer that sits between the SwiftVector governance kernel and FlightLaw. It provides the spatial primitives, OGC standards integration, Core ML imagery pipeline, and GeoPackage mission packaging that any governed spatial application needs.
GeoVector is the layer developers and evaluators can adopt for any governed spatial application. Flightworks Control is its reference implementation.
OGC-compliant spatial query engine — geofences, corridors, restricted zones.
Core ML imagery pipeline with deterministic classification boundaries.
GeoPackage mission packaging for offline-capable edge deployment.
Local-first, Apple Silicon-native — no cloud dependency for spatial evaluation.
| Layer | License |
|---|---|
| AgentVector Codex | Open specification |
| SwiftVector Kernel | MIT open source |
| GeoVector Layer | MIT open source |
| FlightLaw | Proprietary |
| Mission Modules | Proprietary |
| Watch Station | Proprietary |
| Sentinel | Proprietary |
The same constitutional architecture implemented in two languages. SwiftVector powers the principal interface. RustVector powers the edge relay. Both produce identical audit trails from identical action sequences.
Both kernels implement the same reducer contract: reduce(state, action) → state. The audit trail format is identical. An action sequence replayed through SwiftVector and RustVector must produce the same final state hash. This is verified by cross-language determinism tests.
The AgentVector framework, FlightLaw specification, and Sentinel architecture are documented in detail. Technical evaluation starts with the papers and the code.