How to Add Cryptographic AI Compliance Evidence in 10 Minutes (Python + TypeScript)

What You'll Build in 10 Minutes

By the end of this guide, every AI inference in your application will be:

WITNESSED — Cryptographic proof the inference happened
ANCHORED — SWT3 Witness Anchor in the immutable ledger
CLEARED — Raw prompts/responses purged from the wire
AUDITABLE — Mapped to EU AI Act & NIST AI RMF

Zero data retention. At Clearing Level 1+, your prompts and responses never leave your infrastructure. The witness endpoint is a "Blind Registrar" — it stores cryptographic proofs, not data.

Install the SDK

30 seconds

Python

TypeScript

pip install swt3-ai

npm install @tenova/swt3-ai

Zero dependencies. The SDK uses only Python/Node.js standard library + your existing AI client.

Get Your API Key

1 minute

Your key starts with axm_live_. You'll also need your Tenant ID (shown on the Settings page).

Keep your key safe. It's shown once and cannot be recovered. Store it in an environment variable, never in code.

Wrap Your AI Client

3 minutes — this is the only code change

Python + OpenAI

Python + Anthropic

TypeScript + OpenAI

Vercel AI SDK

from swt3_ai import Witness
from openai import OpenAI

# Initialize the witness (once, at startup)
witness = Witness(
    endpoint="https://sovereign.tenova.io",
    api_key=os.environ["SWT3_API_KEY"],
    tenant_id=os.environ["SWT3_TENANT_ID"],
)

# Wrap your client — this is the ONLY change
client = witness.wrap(OpenAI())

# Use it exactly as before. Every inference is now witnessed.
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Summarize this contract"}],
)
print(response.choices[0].message.content)
# ^ Untouched. Zero latency added. Witnessing happens in the background.

from swt3_ai import Witness
from anthropic import Anthropic

witness = Witness(
    endpoint="https://sovereign.tenova.io",
    api_key=os.environ["SWT3_API_KEY"],
    tenant_id=os.environ["SWT3_TENANT_ID"],
)

client = witness.wrap(Anthropic())

message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Draft a compliance memo"}],
)

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

const witness = new Witness({
  endpoint: "https://sovereign.tenova.io",
  apiKey: process.env.SWT3_API_KEY,
  tenantId: process.env.SWT3_TENANT_ID,
});

const client = witness.wrap(new OpenAI()) as OpenAI;

// Works with streaming too
const stream = await client.chat.completions.create({
  model: "gpt-4o",
  messages: [{ role: "user", content: "Hello" }],
  stream: true,
});
for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

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

const witness = new Witness({ /* ... */ });
const prompt = "Summarize this contract for the board";

const result = await streamText({
  model: openai("gpt-4o"),
  prompt,
  onFinish: witness.vercelOnFinish({ promptText: prompt }),
});
// Works with any Vercel AI SDK provider — OpenAI, Anthropic, Google, custom

That's it. No decorators. No middleware. No configuration files. Your AI client works exactly as before — the witness observes silently in the background.

See the Green Dot

Immediate — check your dashboard

Open your Axiom Dashboard → AI Witness page. You'll see:

Inference count — every call is tracked
Model table — pass rate, latency, tokens per model
Amnesia indicator — green dot = raw data was cleared
SWT3 Anchors — each inference gets a cryptographic fingerprint

Every anchor maps to a specific regulatory requirement. Your auditor can verify each one mathematically.

What Gets Witnessed Per Inference

Each inference automatically produces anchors for these procedures:

Procedure	What It Proves	Regulation
`AI-INF.1`	Inference provenance (prompt + response hashed)	EU AI Act Art. 12
`AI-INF.2`	Latency within threshold (detects model swaps)	NIST AI RMF MANAGE 2.2
`AI-MDL.1`	Model hash matches approved version	EU AI Act Art. 9
`AI-MDL.2`	Model version identifier recorded	EU AI Act Art. 72
`AI-GRD.1`	Required safety filters were active	EU AI Act Art. 9(2)(a)
`AI-GRD.2`	No content filter or refusal triggered	EU AI Act Art. 15(3)
`AI-TOOL.1`	Agent tool/function call witnessed with outcome	EU AI Act Art. 12(1)
`AI-ID.1`	Agent cryptographic identity asserted	EU AI Act Art. 12(1)
`AI-ACC.1`	Agent resource access witnessed with scope	EU AI Act Art. 9(4)(c)
`AI-REV.1`	Previously-issued anchor revoked with reason	EU AI Act Art. 14(4)(d)
`AI-EMRG.1`	Emergency override lifecycle: override reason, authorization chain, rollback plan, time-bounded scope, lifecycle stage	EU AI Act Art. 14(4)
`AI-DRIFT.2`	Consequence-mapped drift: threshold config, breach magnitude, affected populations, consequence severity, recommended actions	NIST AI RMF MANAGE 2.4
`AI-ASSESS.1`	Champion-challenger assessment: baseline model, challenger model, evaluation criteria, sample size, statistical significance	NIST AI RMF MEASURE 2.6

Clearing Levels — You Control What Leaves

The Clearing Engine controls what data travels on the wire to the witness endpoint. Your code always gets the full response.

Level	Name	What's on the Wire	Use Case
`0`	Analytics	Hashes + factors + model + provider	Internal analytics
`1`	Standard	Hashes + factors + model	Production apps (default)
`2`	Sensitive	Hashes + factors + model only	Healthcare, legal, PII
`3`	Classified	Numeric factors only, model hashed	Defense, air-gapped

# Set clearing level at initialization
witness = Witness(
    endpoint="https://sovereign.tenova.io",
    api_key="axm_live_...",
    tenant_id="YOUR_ENCLAVE",
    clearing_level=2,  # Sensitive — no provider names on the wire
)

At Level 1+, raw prompts and responses never leave your infrastructure. The witness endpoint stores cryptographic proofs, not data. Your liability is near zero.

Single-Line Configuration (DSN)

For containerized and infrastructure deployments, configure the witness with a single environment variable:

# Set one env var. Done.
export SWT3_DSN="https://axm_live_xxx@sovereign.tenova.io/YOUR_ENCLAVE"

# SDK auto-parses: endpoint, api_key, tenant_id
witness = Witness.from_dsn()
client = witness.wrap(OpenAI())

The DSN format: https://{api_key}@{endpoint}/{tenant_id}. Works with Docker, Kubernetes, Terraform, and any env-var-based config system. The NVIDIA Dynamo adapter uses this exclusively.

Sovereign Cloud — Any Model, Any Infrastructure

The SDK works with any OpenAI-compatible endpoint. Run Llama 3 on vLLM, Mistral on Ollama, or any model behind your own API:

# vLLM on your GPU cluster
client = witness.wrap(OpenAI(base_url="http://gpu-cluster:8000/v1"))

# Ollama (local development)
client = witness.wrap(OpenAI(base_url="http://localhost:11434/v1"))

# Same SWT3 anchors, same ledger, same audit trail
# Regardless of where the model runs

Lifecycle Chains (v0.6.0)

Some compliance events are not single moments. Emergency overrides, model replacements, and champion-challenger evaluations unfold over time. Lifecycle chains link multiple SWT3 Witness Anchors into a single auditable sequence, connected by a shared cycle ID.

Each anchor in the chain records a stage (INITIATED, MONITORING, RESOLVED) so auditors can trace the full progression of an operational governance event.

Python

from swt3_ai import SWT3Witness

witness = SWT3Witness(api_key="your-key", tenant="your-tenant")

# Start a lifecycle chain (e.g., emergency override)
chain = witness.start_chain("AI-EMRG.1", reason="model_recall", stage="INITIATED")

# Add monitoring anchors as the override progresses
witness.add_to_chain(chain.cycle_id, "AI-EMRG.1", stage="MONITORING",
    observations={"status": "rollback_in_progress"})

# Close the lifecycle
witness.add_to_chain(chain.cycle_id, "AI-EMRG.1", stage="RESOLVED",
    observations={"resolution": "rollback_complete", "duration_minutes": 45})

TypeScript

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

const witness = new SWT3Witness({ apiKey: "your-key", tenant: "your-tenant" });

// Start a lifecycle chain
const chain = await witness.startChain("AI-EMRG.1", {
  reason: "model_recall", stage: "INITIATED"
});

// Add monitoring anchors
await witness.addToChain(chain.cycleId, "AI-EMRG.1", {
  stage: "MONITORING",
  observations: { status: "rollback_in_progress" }
});

// Close the lifecycle
await witness.addToChain(chain.cycleId, "AI-EMRG.1", {
  stage: "RESOLVED",
  observations: { resolution: "rollback_complete", durationMinutes: 45 }
});

Chain verification. Every anchor in a lifecycle chain can be independently verified on the Verify page. The chain context shows all related anchors, their stages, and the shared cycle ID linking them together.

What's Next

You're witnessing. Here's what to explore next:

Agent Identity & Signing — bind a cryptographic identity to your agent (AI-ID.1)
Tool & Access Witnessing — witness every tool call and resource access (AI-TOOL.1, AI-ACC.1)
Anchor Revocation — recall a previously-issued anchor with a reason code (AI-REV.1)
CJT Fields (EU AI Act) — jurisdiction, legal basis, and purpose classification
NVIDIA Dynamo — infrastructure-layer witnessing for Dynamo inference servers
OTel Export — send witness telemetry to Jaeger, Grafana, or Datadog
Gatekeeper Mode — block unwitnessed inferences in regulated environments
Lifecycle Chains — link multi-step events (overrides, assessments, drift responses) into auditable sequences
Chain Verification — verify any anchor and see the full lifecycle chain context on the public verify page
Operational Governance — emergency overrides (AI-EMRG.1), consequence-mapped drift (AI-DRIFT.2), champion-challenger assessment (AI-ASSESS.1)

Full SDK reference: Developer Documentation

Start Witnessing →