Welcome to the **VITI Magazine* FAQ edition—where we skip the 50-page enterprise risk matrices, banish Change Advisory Board (CAB) theater, and replace hopeful PDF policies with deterministic runtime physics.*

If you are trying to figure out how to keep autonomous AI agents (or over-caffeinated deployment pipelines) from wrecking production without hiring an army of compliance consultants, here is the entire Business Impact Governance Framework (BIGF v2.4) boiled down to three blunt questions and a runnable Python gate.

Q1: Do we really need a 6-month Business Impact Analysis (BIA) project before automating governance?

No. If your governance model requires a 50-page risk matrix and four steering committees to approve a routine change, you don't have governance—you have an expensive hobby.

To keep an AI agent from blowing up your budget or taking down core services, leadership only needs to answer three concrete questions (we call it BIA for Dummies):

  1. How much money is allowed to burn in a single shot? (B-Axis — Business Impact): If an autonomous bot hallucinates or goes off the rails, what is the hard financial ceiling (in EUR/USD) it is permitted to approve in a single transaction without human intervention? (e.g., 5000.0000 EUR)
  2. How healthy does the house need to be before the robot touches the stove? (S-Axis — Situational State / BIII): What is the minimum operational integrity required for automated execution? If telemetry is lagging, P1 incidents are active, or observability drops, the Business Impact Integrity Index (BIII) falls below 0.8000 and the valve slams shut immediately.
  3. How long is a permission slip valid before it self-destructs? (T-Axis — Telemetry & Time): How many seconds does a single cryptographic mandate live before expiring automatically? (e.g., 60 seconds—no recycled tokens, no stale agent loops.)

Q2: Why can't we just put these rules in the AI agent's system prompt?

Because polite instructions are not security boundaries. A prompt injection, a context-window glitch, or a standard IEEE 754 floating-point rounding quirk (0.1 + 0.2 != 0.3) will happily walk right past a system prompt.

BIGF enforces governance outside the LLM at the runtime actuation gate:

  • Zero Floating-Point Drift (BIGF-DCS): Standard JSON floats are rejected at the door with 422 Unprocessable. All financial and threshold math runs in strict 10-4 fixed-point decimal precision using Banker's Rounding (ROUND_HALF_EVEN).
  • Deterministic Serialization (RFC 8785): Payloads are canonicalized into identical UTF-8 byte streams before hashing or signing.
  • Cryptographic Mandates (Ed25519 / RFC 8032): Every request must carry a valid Ed25519 signature from the calling agent, and every decision—pass or fail—produces a signed Canonical Decision Record (CDR) for zero-effort audits.

Q3: Can I actually run this without buying an enterprise platform?

Yes. Install cryptography (pip install cryptography) and run the complete, self-contained BIGF v2.4 Runtime Gate below. It tests four real-world scenarios out of the box: a valid signed execution (200 OK), a tampered payload (403 Hard Halt), a policy/integrity breach (403 Hard Halt), and an illegal floating-point payload (422 Rejected).

import hashlib import json import time from decimal import Decimal, ROUND_HALF_EVEN from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey from cryptography.exceptions import InvalidSignature # 1. "BIA for Dummies" — Hard business boundaries (10^-4 fixed-point precision) BIA_POLICY = { "max_eur": Decimal("5000.0000"), "min_biii": Decimal("0.8000"), } # Generate Ed25519 keypairs for the calling Agent and the BIGF Runtime Gate AGENT_PRIVATE_KEY = Ed25519PrivateKey.generate() AGENT_PUBLIC_KEY = AGENT_PRIVATE_KEY.public_key() GATE_PRIVATE_KEY = Ed25519PrivateKey.generate() GATE_PUBLIC_KEY = GATE_PRIVATE_KEY.public_key() def canonicalize_jcs(payload: dict) -> bytes: """RFC 8785 deterministic JSON canonicalization into UTF-8 bytes.""" canonical_str = json.dumps( payload, sort_keys=True, separators=(",", ":"), ensure_ascii=False ) return canonical_str.encode("utf-8") def validate_no_floats(obj): """BIGF-DCS Ingress Guard: Bans IEEE 754 floats to prevent rounding drift.""" if isinstance(obj, float): raise ValueError("422 Unprocessable (BIGF-DCS Type Violation: float detected)") if isinstance(obj, dict): for v in obj.values(): validate_no_floats(v) elif isinstance(obj, list): for item in obj: validate_no_floats(item) def sign_cdr(cdr_body: dict) -> dict: """Signs the Canonical Decision Record (CDR) with the Gate's Ed25519 key.""" canonical_bytes = canonicalize_jcs(cdr_body) signature_hex = GATE_PRIVATE_KEY.sign(canonical_bytes).hex() cdr_body["gate_signature_ed25519"] = signature_hex return cdr_body def bigf_runtime_gate( payload: dict, agent_signature_hex: str, live_biii: str, attestation_online: bool ) -> dict: """Deterministic BIGF v2.4 runtime gate with Ed25519 verification and fail-closed physics.""" try: # Step 1: Ingress sanitization (no IEEE 754 floats allowed) validate_no_floats(payload) # Step 2: JCS canonicalization & Agent Ed25519 signature verification canonical_bytes = canonicalize_jcs(payload) payload_hash = hashlib.sha256(canonical_bytes).hexdigest() try: AGENT_PUBLIC_KEY.verify(bytes.fromhex(agent_signature_hex), canonical_bytes) except (InvalidSignature, ValueError): return sign_cdr({ "status": "403 HARD HALT", "state": "UNVERIFIED_CRITICAL_STATE", "privileges_propagated": 0, "violations": ["CRYPTO_AXIS: Invalid Ed25519 agent signature"], "input_jcs_sha256": payload_hash, "timestamp_utc": int(time.time()), }) # Step 3: Fixed-point conversion (10^-4 Banker's Rounding) amount = Decimal(payload["amount_fp4"]).quantize( Decimal("0.0001"), rounding=ROUND_HALF_EVEN ) biii = Decimal(live_biii).quantize( Decimal("0.0001"), rounding=ROUND_HALF_EVEN ) now = int(time.time()) # Step 4: B x S x T invariant evaluation violations = [] if not attestation_online: violations.append("S_AXIS: Attestation telemetry OFFLINE") if biii < BIA_POLICY["min_biii"]: violations.append( f"S_AXIS: BIII {biii} < required {BIA_POLICY['min_biii']}" ) if amount > BIA_POLICY["max_eur"]: violations.append( f"B_AXIS: Amount {amount} > BIA limit {BIA_POLICY['max_eur']}" ) if now > payload["exp"]: violations.append("T_AXIS: Contract expired") # Step 5: Emit cryptographically signed Canonical Decision Record (CDR) if violations: return sign_cdr({ "status": "403 HARD HALT", "state": "UNVERIFIED_CRITICAL_STATE", "privileges_propagated": 0, "violations": violations, "input_jcs_sha256": payload_hash, "timestamp_utc": now, }) return sign_cdr({ "status": "200 OK", "state": "VERIFIED_EXECUTION", "approved_amount_fp4": str(amount), "biii_fp4": str(biii), "input_jcs_sha256": payload_hash, "timestamp_utc": now, }) except ValueError as err: return sign_cdr({ "status": "422 REJECTED", "reason": str(err), "privileges_propagated": 0, "timestamp_utc": int(time.time()), }) # --- TEST SUITE --- valid_time = int(time.time()) + 60 # Test 1: Valid Ed25519 signature & within B x S x T bounds -> 200 OK tx_ok = {"agent": "pay-bot-01", "amount_fp4": "1250.5000", "exp": valid_time} sig_ok = AGENT_PRIVATE_KEY.sign(canonicalize_jcs(tx_ok)).hex() print("TEST 1 (200 OK):", json.dumps(bigf_runtime_gate(tx_ok, sig_ok, "0.9200", True), indent=2)) # Test 2: Payload tampered after signing -> 403 HARD HALT tx_tampered = {"agent": "pay-bot-01", "amount_fp4": "4999.0000", "exp": valid_time} print("TEST 2 (TAMPERED):", json.dumps(bigf_runtime_gate(tx_tampered, sig_ok, "0.9200", True), indent=2)) # Test 3: BIA ceiling exceeded & BIII dropped below 0.8000 -> 403 HARD HALT tx_breach = {"agent": "pay-bot-01", "amount_fp4": "9500.0000", "exp": valid_time} sig_breach = AGENT_PRIVATE_KEY.sign(canonicalize_jcs(tx_breach)).hex() print("TEST 3 (BREACH):", json.dumps(bigf_runtime_gate(tx_breach, sig_breach, "0.7500", True), indent=2)) # Test 4: Forbidden IEEE 754 float in payload -> 422 REJECTED tx_float = {"agent": "pay-bot-01", "amount_fp4": 1250.5, "exp": valid_time} sig_float = AGENT_PRIVATE_KEY.sign(canonicalize_jcs(tx_float)).hex() print("TEST 4 (FLOAT):", json.dumps(bigf_runtime_gate(tx_float, sig_float, "0.9200", True), indent=2))

Q4: What does the auditor get when they ask for proof?

Zero screenshots. Every single decision—whether 200 OK, 403 HARD HALT, or 422 REJECTED—outputs a signed Canonical Decision Record (CDR) containing the exact SHA-256 hash of the canonicalized input, the evaluated BIII score, the specific axis violations, a UTC timestamp, and the gate's Ed25519 signature.

Governance shouldn't rely on human approval queues or hope. If it isn't enforced at runtime, it's just theater.

Explore the full BIGF v2.4 specification & open-access whitepapers:

Just Google it: BIG framework Erkki Laine (available on Zenodo & ORCID under CC BY-NC 4.0) ✌️