Domain-agnostic. The same kernel enforces a desktop AI agent's filesystem boundaries and a drone's geospatial envelope. The domain provides constraints. The kernel provides deterministic evaluation and faithful audit logging. This is where everything in the programme converges.
Each week builds on the last. By week four, students have a working governance kernel for a domain they chose, with determinism tests that prove replay correctness.
Read and discuss the Agency Paradox. Understand why behavioral governance fails at scale. Identify the composition problem in real AI agent deployments. Examine failure modes: what happens when individually compliant actions collectively constitute scope creep.
Study SwiftVector's four-layer architecture: Constraints, Codex, Domain contexts, and the Evaluation engine. Trace the lineage from Euclid's definitions-postulates-propositions to SwiftVector's definitions-axioms-laws-evaluations. Read the AgentVector Codex. Implement your first constraint evaluator.
Build a complete SwiftVector domain. Swift actors as governance boundaries. Sendable types as the state model. Pure reducers with no side effects. Injected dependencies for clock, ID generation, and randomness. Audit trail logging with os.log. XCTest determinism verification.
Choose a domain the programme has not covered. Design the constraint set. Implement the reducer. Wire the audit trail. Write the determinism tests. Present the governance architecture to the cohort with a live replay demonstration.
Assessment is structural, not conversational. Each criterion is binary or graduated — the artifact either demonstrates the property or it does not.
AI tools are part of the learning environment, not a bypass for it. This module specifies where AI is permitted and where it is constrained.
Common misconception: Students often assume governance means restriction. Emphasise that governance enables autonomy — the clearer the boundaries, the more freedom the agent has within them. The analogy to Swift's actor isolation is direct: the compiler's strictness is what makes concurrency safe.
Geometry gave us the axiomatic method. Calculus gave us optimisation. Linear algebra gave us transformations and attention. Statistics gave us reasoning under uncertainty. Specifying Systems gave us formal specification. SwiftVector is where all of it converges: a governance kernel that inherits Euclid's four-layer architecture, enforces constraints with deterministic evaluation, and produces a faithful audit trail of every decision.
The kernel doesn't know what it's governing. A filesystem boundary and a geospatial envelope are the same thing to SwiftVector: constraints that evaluate to ALLOW, DENY, or ESCALATE. The domain provides the constraints. The kernel provides the evaluation engine. This separation is what makes governance portable across every application domain.
Every evaluation must produce the same result given the same inputs. No Date(), no UUID(), no .random() inside reducers. Replay must work. The audit trail must be complete. This is the same standard Euclid held: every proposition must be derivable from what came before.
Explore the SwiftVector kernel's architecture. Constraints, Codex, domain contexts, and the evaluation engine — with code examples showing how the same kernel serves both filesystem governance and geospatial governance.
// The base protocol for all governance constraints. // Deterministic. Stateless. Single-purpose. public protocol Constraint: Sendable { // Stable identifier used in audit logs var identifier: String { get } // Higher priority evaluates first var priority: Int { get } // Same input = same output. Always. func evaluate(_ action: Action, context: some DomainContext) -> Verdict }
// Boundary = filesystem path scope
func evaluate(_ action, context) {
if ctx.immutablePaths
.contains(action.subject) {
return .deny(
reason: "Constitutionally immutable")
}
return isWithinBoundary(...)
? .allow : .deny(...)
}// Boundary = geofence polygon
func evaluate(_ action, context) {
guard action.metadata["command"]
== "navigate" else {
return .allow
}
return isWithinBoundary(...)
? .allow : .deny(
reason: "Outside operational fence")
}