Autonomous Vehicle AI Compliance: How to Add Cryptographic Accountability to VLA Models and Trajectory Planning

1. Why Autonomous AI Needs Accountability

Your vehicle's planning model makes 10-30 trajectory decisions per second. Each one is a safety-critical action that regulators can ask you to explain. When an assessor, a regulator, or an accident investigator asks "what did the AI decide at 14:32:07 and why?" -- the answer needs to be a verifiable record, not a log file.

Open-weight VLA (Vision-Language-Action) models released under permissive licenses have lowered the barrier to building autonomous driving systems. Startups can fine-tune a 34-billion-parameter foundation model and distill it to edge hardware. The technology is accessible. The accountability infrastructure is not.

Three regulatory frameworks converge on this gap:

• EU AI Act Annex III(3a) explicitly lists autonomous vehicles as high-risk AI systems. Article 9 requires documented risk management. Article 12 requires automatic logging of events relevant to identifying risks. Article 15 requires accuracy, robustness, and cybersecurity measures.
• ISO/PAS 8800 is the harmonized standard for road vehicle AI safety. Clauses 6-10 cover the full lifecycle from design to deployment, including trajectory validation and operational safety classification.
• UNECE WP.29 Regulation 157 governs automated lane-keeping systems and requires evidence of system behavior during operation -- what the AI decided, when, and why.

SWT3 provides two procedures for autonomous AI governance:

• AI-MOB.6 (Trajectory Decision Attestation) -- witnesses that a VLA or planning model produced a trajectory and whether it passed safety validation
• AI-MOB.7 (VLA Inference Witnessing) -- wraps any VLA inference function to capture timing, success/failure, and I/O hashes transparently

2. Trajectory Decision Attestation (AI-MOB.6)

Every trajectory decision your planning model makes can be witnessed with a single method call. The anchor records whether the trajectory passed safety validation, its classification level, and optional provenance metadata -- all as hashes, never raw data.

Python

import hashlib
from swt3_ai import Witness

witness = Witness(
    endpoint="https://sovereign.tenova.io",
    api_key="axm_live_...",
    tenant_id="YOUR_TENANT",
)

# Hash your trajectory data before witnessing -- raw data never leaves your system
traj_hash = hashlib.sha256(trajectory_bytes).hexdigest()
coc_hash = hashlib.sha256(reasoning_trace_json.encode()).hexdigest()

witness.witness_trajectory(
    safety_validated=True,
    waypoint_count=47,
    trajectory_hash=traj_hash,
    coc_trace_hash=coc_hash,
    action_class="navigate",
    safety_classification="nominal",
    sensor_sources=["camera_front", "camera_rear", "lidar_top", "radar"],
    model_id="alpamayo-2-super",
)

TypeScript

import { createHash } from "node:crypto";
import { Witness } from "@tenova/swt3-ai";

const witness = new Witness({
  tenantId: "YOUR_TENANT",
  apiKey: "axm_live_...",
});

// Hash locally -- raw trajectory data never leaves your system
const trajHash = createHash("sha256").update(trajectoryBytes).digest("hex");
const cocHash = createHash("sha256").update(reasoningTraceJson).digest("hex");

witness.witnessTrajectory({
  safetyValidated: true,
  waypointCount: 47,
  trajectoryHash: trajHash,
  cocTraceHash: cocHash,
  actionClass: "navigate",
  safetyClassification: "nominal",
  sensorSources: ["camera_front", "camera_rear", "lidar_top", "radar"],
  modelId: "alpamayo-2-super",
});

MCP (Model Context Protocol)

// Any MCP client can call the witness_trajectory tool:
{
  "tool": "witness_trajectory",
  "arguments": {
    "safety_validated": true,
    "waypoint_count": 47,
    "trajectory_hash": "a1b2c3d4e5f6...",
    "action_class": "navigate",
    "safety_classification": "nominal",
    "sensor_sources": ["camera_front", "lidar_top"],
    "model_id": "alpamayo-2-super"
  }
}

Factor Semantics

What Gets Stored at Each Clearing Level

3. VLA Inference Wrapping (AI-MOB.7)

Wrap any VLA inference function and every call is witnessed automatically. The wrapper captures timing, input/output hashes, and success/failure. It works with any callable -- not coupled to any specific model API or framework.

Python -- Wrapper Pattern

from swt3_ai import Witness

witness = Witness(tenant_id="YOUR_TENANT", api_key="axm_live_...")

# Wrap any inference function
infer = witness.wrap_vla(model.predict, model_id="alpamayo-2-super")

# Every call is now witnessed (AI-MOB.7)
trajectory = infer(camera_frames)

Python -- Decorator Pattern

@witness.wrap_vla(model_id="alpamayo-2-super")
def predict(frames):
    return model.forward(frames)

# Each call mints an AI-MOB.7 anchor automatically
trajectory = predict(camera_frames)

TypeScript

import { Witness } from "@tenova/swt3-ai";

const witness = new Witness({ tenantId: "YOUR_TENANT" });

const infer = witness.wrapVLA(model.predict, "alpamayo-2-super");

// Sync or async -- both work transparently
const trajectory = await infer(cameraFrames);

Factor Semantics

# With pre-computed frame hashes from your camera pipeline
infer = witness.wrap_vla(
    model.predict,
    model_id="alpamayo-2-super",
    input_frame_hashes=["a1b2c3...", "d4e5f6...", "g7h8i9..."],
)
trajectory = infer(camera_frames)

4. Safety Classification Codes

The safety_classification parameter encodes the operational state of the vehicle when the trajectory decision was made. This maps to factor_c in the witness anchor.

# Emergency braking during lane change
witness.witness_trajectory(
    safety_validated=False,
    safety_classification="emergency",
    action_class="change_lane",
    model_id="alpamayo-2-super",
)

# Trajectory rejected before execution
witness.witness_trajectory(
    safety_validated=False,
    safety_classification="abort",
    action_class="navigate",
    model_id="alpamayo-2-super",
)

The SAFETY_CLASSIFICATION_CODES dictionary is exported from both SDKs for programmatic use:

# Python
from swt3_ai import SAFETY_CLASSIFICATION_CODES
# {"reserved": 0, "nominal": 1, "cautionary": 2, "degraded": 3, "emergency": 4, "abort": 5}

// TypeScript
import { SAFETY_CLASSIFICATION_CODES } from "@tenova/swt3-ai";
// { reserved: 0, nominal: 1, cautionary: 2, degraded: 3, emergency: 4, abort: 5 }

5. Multi-Sensor Fusion Provenance

Autonomous vehicles fuse data from multiple sensor types: cameras, LiDAR, radar, ultrasonic, GPS, and IMU. The sensor_sources parameter captures which sensors contributed to the trajectory decision without exposing raw sensor data.

witness.witness_trajectory(
    safety_validated=True,
    sensor_sources=[
        "camera_front_wide",
        "camera_front_narrow",
        "camera_rear",
        "camera_left",
        "camera_right",
        "lidar_top",
        "radar_front",
        "radar_rear",
        "imu",
    ],
    model_id="your-vla-model",
)

What survives at each clearing level:

• Level 0-1: Full sensor_sources list and sensor_count
• Level 2: sensor_count only (e.g., 9). No sensor names. Auditor knows how many sensors contributed but not the sensor configuration.
• Level 3: Neither. Factors only.

6. Offline and Edge Operation

Vehicles operate offline. Tunnels, rural roads, underground parking, and cellular dead zones are normal operating conditions. SWT3 handles this with the same write-ahead log (WAL) architecture used across all edge deployments.

How It Works

1. Every witness_trajectory() call writes the payload to a local WAL file immediately
2. The WAL survives process restarts and power loss
3. When connectivity returns, flush() drains the WAL to the clearing house
4. AI-MOB.5 (Bilateral Flush Correlation) verifies all locally buffered anchors were successfully correlated after flush

# No endpoint = local-only mode (WAL captures everything)
witness = Witness(clearing_level=2)

# Drive for 2 hours through a tunnel...
for frame_batch in camera_pipeline:
    trajectory = model.predict(frame_batch)
    witness.witness_trajectory(
        safety_validated=trajectory.safety_passed,
        waypoint_count=len(trajectory.waypoints),
        trajectory_hash=sha256(trajectory.serialize()),
        model_id="your-vla-model",
    )

# Back online -- drain the WAL
receipts = witness.flush()
print(f"Flushed {len(receipts)} trajectory anchors")

7. Performance Constraints

Autonomous driving systems have strict latency budgets. The witnessing layer must add negligible overhead.

SWT3 achieves this through three design decisions:

• No raw frame hashing. Camera frames are large (6MB+ per frame, 6-12 cameras). Hashing pixel data adds 50-200ms. The wrapper hashes lightweight metadata instead, or accepts pre-computed hashes from your existing camera pipeline.
• Non-blocking buffer. enqueue_many() writes to an in-memory buffer. Flush happens on a background thread. The inference loop is never blocked by network I/O.
• SHA-256 fingerprint minting is fast. One SHA-256 hash of a ~100 byte string takes microseconds. The fingerprint formula is deterministic and requires no network calls.

Recommended Configuration

# High-frequency AV configuration
witness = Witness(
    endpoint="https://sovereign.tenova.io",
    api_key="axm_live_...",
    tenant_id="YOUR_TENANT",
    clearing_level=2,       # Sensitive -- hashes only, no raw context
    buffer_size=100,         # Flush every 100 payloads
    flush_interval=10.0,     # Or every 10 seconds, whichever comes first
)

8. Regulatory Framework Mapping

AI-MOB.6 and AI-MOB.7 map to four regulatory frameworks that govern autonomous vehicle AI systems:

9. Verification and Audit Presentation

Creating evidence is half the story. Presenting it to a regulator, assessor, or accident investigator is the other half. Every witness anchor can be independently verified without access to your systems.

What an Assessor Sees

When your ISO/PAS 8800 assessor or EU AI Act notified body asks for trajectory decision evidence, you provide the SWT3 anchor fingerprint. They verify it independently:

# Verify a single anchor fingerprint
curl https://sovereign.tenova.io/api/v1/attest/verify?token=SWT3-E-VULTR-AI-AIMOB6-PASS-1774800010-a1b2c3d4e5f6

The verification response confirms the procedure, verdict, timestamp, and that the anchor has not been tampered with. The assessor does not need access to your dashboard, your model, or your trajectory data. The anchor is self-verifying.

What a Regulator Sees During Investigation

After an incident, the regulator needs the full timeline: what the AI decided, when, in what order, and whether safety systems intervened. The forensic timeline reconstruction API returns a chronological view of all anchors for a given time window:

# Reconstruct all trajectory decisions in a 60-second window
curl "https://sovereign.tenova.io/api/v1/reconstruct?start=1774800000000&end=1774800060000&procedure=AI-MOB.6" \
  -H "Authorization: Bearer axm_live_..."

The response includes every trajectory anchor with its safety classification, verdict, and timestamp. Emergency (code 4) and abort (code 5) events are flagged automatically. The regulator gets the answer to "what did the AI do in the 30 seconds before the incident" without depending on your application logs.

Public Verification Portal

Any anchor can be verified through the public portal at /verify -- no authentication required. Paste the SWT3 anchor string or fingerprint and get immediate confirmation of procedure, verdict, and timestamp integrity.

10. When to Use MOB.6 vs SAFE.1 vs CHAIN.1

SWT3 has multiple procedures that touch autonomous system governance. Here is when to use each:

These procedures are complementary. A single driving scenario might generate all of them:

1. MOB.7 -- VLA inference call witnessed (every frame)
2. MOB.6 -- trajectory decision attested (every planning cycle)
3. SAFE.1 -- emergency braking triggered (rare, reactive)
4. CHAIN.1 -- planner hands trajectory to controller (agent boundary)
5. EMRG.1 -- driver disengages autonomous mode (override lifecycle)

11. Quick Reference

MOB Namespace (Mobile Edge Governance)

Install

Minimal Example (3 Lines)

from swt3_ai import Witness

witness = Witness(endpoint="https://sovereign.tenova.io", api_key="axm_live_...", tenant_id="YOUR_TENANT")
witness.witness_trajectory(safety_validated=True, model_id="your-vla-model")

Full SDK documentation: sovereign.tenova.io/docs

UCT Registry (109 procedures): sovereign.tenova.io/registry

Create a free account: sovereign.tenova.io/signup