Architecture Overview

What AgentVector is

AgentVector is a framework for governing autonomous AI agents. It exists to close a specific gap: an agent reasons probabilistically, but the actions it emits — writing a file, sending a command, moving money, flying an aircraft — hit a deterministic world with real consequences.

The framework's central claim is that authority must live in state, not in prompts. A prompt can shape what an agent is likely to propose, but it cannot bind what a system will actually do — it is interpreted anew on every run and can be reworded around. AgentVector moves the binding decision out of the model's output and into a deterministic layer the model can inform but never unilaterally cross.

The framework has three parts, each answering a different question:

• The Codex — a specification of governing Laws. Defines what must be enforced, in language, with no code. Read the Codex →
• SwiftVector — the enforcement kernel. A deterministic state machine, written in Swift, that decides whether a proposed action is permitted.
• Governance layers — domain-specific compositions (for aviation, desktop agents, records) that apply the Codex's Laws to where the agent operates.

How an action flows

Every consequential action an agent wants to take passes through the same path. The agent never touches the outside world directly; it proposes, and the kernel decides.

The key property is that the reducer is deterministic. Given the same state and the same proposed action, it returns the same verdict every time — which is what makes a governed run replayable: you can re-run the recorded sequence and reproduce every decision exactly. For safety cases and audits, that reproducibility is the whole point.

The verdict contract

Every action the reducer evaluates resolves to exactly one of three verdicts. This three-state gate is the core of the enforcement model.

The presence of ESCALATE is what keeps a human meaningfully in command rather than nominally in the loop. It is not a catch-all for uncertainty; it is a deliberate handoff for the specific decisions the system is designed to reserve for a person.

Reading a verdict in code

A caller integrates the kernel by routing every side-effecting action through the reducer and acting only on an allowed verdict:

// The agent proposes; the reducer governs; effects run only on .allow
let verdict = reducer.evaluate(action, in: currentState)

switch verdict {
case .allow(let effect):
    effect.run()                 // only reachable path to the outside world
case .deny(let reason):
    log.blocked(action, reason)  // recorded, never executed
case .escalate(let request):
    principal.present(request)   // held for human decision
}

Why this is different from prompt-based control

A prompt-governed agent that "usually" refuses an unsafe action is one clever rephrasing away from performing it, because the refusal lives in the same probabilistic layer as everything else the model does. A state-governed agent cannot be talked past the boundary, because the boundary is not something the model evaluates — it is a deterministic gate the model's output must pass through before any effect runs.

Where to go next

• The Codex (Laws 0–10) — the full specification of what each Law enforces.
• AgentVector hub — proof chain, kernels, and jurisdiction map for the full framework reference.
• Terminology glossary — framework terms paired with industry equivalents.
• Governance jurisdictions — how Laws compose for specific domains: DesktopGovernance (Vigil), FlightGovernance (Flightworks), ChronicleGovernance (Chronicle Quest).