DEV Community

Erkki Laine
Erkki Laine

Posted on

VITI Labs: Why Probabilistic AI Guardrails Approve Friday Outages (And How to Compile Deterministic Gates)

By VITI Labs Research Desk | VITI Magazine — Empirical Systems & Deterministic Governance


Executive Field Note: The Illusion of the "Polite" Guardrail

Every modern enterprise currently has two incompatible layers stacked on top of each other:

  1. High-speed autonomous execution: Agent2Agent (A2A) delegation meshes, Model Context Protocol (MCP) tool-calling servers, and automated CI/CD or ITSM pipelines capable of mutating production infrastructure in milliseconds.
  2. Slow, probabilistic, or theatrical governance: Either a 15-person Change Advisory Board (CAB) rubber-stamping 40 tickets in 30 minutes, or a secondary "LLM-as-a-Judge" prompt politely asking a neural network whether a production database migration feels safe.

At VITI Labs, we call this Governance Theater. A probabilistic model cannot enforce a hard financial boundary, and an IEEE-754 floating-point comparison (0.1 + 0.2 > 0.30000000000000004) has no business deciding whether an automated remediation loop is authorized to shift global routing during peak traffic.

In the Business Impact Governance Framework (BIGF v2.4), connectivity protocols like A2A and MCP provide the plumbing, while a deterministic Runtime Control-Plane enforces the traffic laws.


1. The Core Axiom: Authority = f(B, S, T)

BIGF v2.4 eliminates subjective risk scoring by compiling operational boundaries into a fail-closed, machine-verifiable BIA Anchor Specification hashed via RFC 8785 (JSON Canonicalization Scheme / JCS).

An automated agent, A2A sub-delegation, or ServiceNow change transition is granted execution authority (HTTP 200 ALLOW) if and only if three orthogonal invariants hold simultaneously at runtime:

Axis Dimension Deterministic Invariant Fail-Closed Halt Code (HTTP 403)
B Business Impact Action is explicitly allowlisted AND live hourly exposure <= ceiling (10⁻⁴ integer scale) B_AXIS_ACTION_FORBIDDEN / B_AXIS_EXPOSURE_EXCEEDED
S Situational Integrity Cryptographic anchor_sha256 matches pinned policy AND live BIII >= threshold (min of 4 telemetry signals) ANCHOR_DIGEST_MISMATCH / S_AXIS_BIII_BELOW_THRESHOLD
T Temporal Bounds Authorization token age <= max_ttl_seconds AND outside restricted freeze windows (unless Break-Glass active) T_AXIS_TTL_EXPIRED / T_AXIS_FREEZE_WINDOW_ACTIVE

Why Pure Integer 10⁻⁴ Fixed-Point Matters

Standard JSON parsers convert decimal numbers into IEEE-754 binary floating-point values, introducing silent rounding drift across languages (Python, Go, Rego, JavaScript). BIGF v2.4 forbids floating-point arithmetic in policy evaluation: every currency ceiling and telemetry ratio is scaled by 10,000 (10⁴), so 0.8000 is evaluated strictly as integer 8000, and 250000.0000 EUR/hr as 2500000000.


2. Inside the Deterministic Gate: OPA / Rego v1

Below is the exact fixed-point parser and invariant evaluation logic compiled by BIGF Gate Studio for Open Policy Agent (OPA):

package bigf.gate

import rego.v1

default allow := false

# Pure Integer Fixed-Point Parser (10^-4 Scale)
# Validates exact 4-decimal format '^\d+\.\d{4}$' and parses pure integer digits.
parse_fp4(s) := val if {
    regex.match("^\\d+\\.\\d{4}$", s)
    parts := split(s, ".")
    digits := concat("", [parts[0], parts[1]])
    val := to_number(digits)
}

# B-Axis: Financial Exposure Ceiling
breaches contains "B_AXIS_EXPOSURE_EXCEEDED" if {
    live_exposure := parse_fp4(input.estimated_exposure_eur_hr_fp4)
    ceiling := parse_fp4(anchor.b_axis.max_exposure_eur_hr_fp4)
    live_exposure > ceiling
}

# S-Axis: Weakest-Link Telemetry Integrity Index (BIII)
breaches contains "S_AXIS_BIII_BELOW_THRESHOLD" if {
    live_biii := parse_fp4(input.telemetry.biii_fp4)
    threshold := parse_fp4(anchor.s_axis.min_biii_fp4)
    live_biii < threshold
}

# Break-Glass Override: Time-bounded (<= 900s), change-bound, commander-attributed
break_glass_valid if {
    input.break_glass.active == true
    input.break_glass.change_id == input.change_id
    input.break_glass.age_seconds >= 0
    input.break_glass.age_seconds <= anchor.t_axis.break_glass_max_ttl_seconds
    count(trim_space(input.break_glass.commander_id)) > 0
}
Enter fullscreen mode Exit fullscreen mode

Weakest-Link Telemetry (BIII) Instead of Averaging

A classic monitoring trap is averaging health metrics: if three subsystems are at 1.0000 and your upstream identity provider is failing at 0.4000, an arithmetic mean gives you 0.8500—greenlighting a deployment straight into an outage.

BIGF computes the Business Impact Integrity Index (BIII) as a strict integer minimum across four live signals:

BIII = min(S_telemetry, S_dependency, S_capacity, S_drift)
Enter fullscreen mode Exit fullscreen mode

If heartbeat freshness (S_telemetry) goes stale (>30s), it drops automatically to 0.4000, halting blind execution before a cascade begins.


3. Bridging A2A, MCP, and ServiceNow Change Management

How does a compiled Rego gate stop real-world mutations across both autonomous agent meshes and traditional ITSM platforms?

A. Horizontal (A2A) & Vertical (MCP) Agent Enforcement

  • Agent2Agent (A2A): When an orchestrator agent reads a peer's Agent Card (/.well-known/agent.json) and attempts to delegate a subtask, the BIGF control-plane validates cryptographic machine identity, caps delegation chain depth, and propagates the parent's FinOps exposure ceiling.
  • Model Context Protocol (MCP): Before an agent executes an MCP tool call (e.g., update_routing_table or execute_refund), the gate evaluates the tool payload against live BIII telemetry and writes an immutable, SHA-256-sealed Canonical Decision Record (CDR) for EU AI Act and DORA auditability.

B. Zero-Dependency ServiceNow Runtime Gate (bigf-servicenow-gate)

In enterprise ITSM, blocking an unauthorized change_request state transition via current.setAbortAction(true) normally triggers a database transaction rollback—erasing any audit work_notes written during the Before Update Business Rule.

The open-source BIGF ServiceNow Runtime Gate solves this with a three-part, zero-external-dependency architecture:

  1. BIGFGateClient.js (Script Include): Canonicalizes the change payload using RFC 8785 JCS, enforces 10⁻⁴ fixed-point scaling, and evaluates policy pins + telemetry freshness against OPA (failing closed to 403 HARD HALT on any timeout or hash mismatch).
  2. BIGF_Change_Gate_BR.js (Before Update Business Rule): Intercepts transitions to Assess or Authorize and aborts execution if decision.allow !== true.
  3. BIGF_Persist_Halt_CDR.js (Post-Rollback Script Action): Listens for the asynchronous x_bigf.gate.hard_halt event queued prior to rollback, writing the tamper-evident Canonical Decision Record (CDR) into u_bigf_decision_log and work_notes after the rollback completes.

4. Try It Yourself (100% Air-Gapped Browser Compiler)

You do not need to install a CLI, sign up for a SaaS control plane, or trust a cloud endpoint to test this architecture.

  1. Compile & Simulate in Your Browser: Open BIGF v2.4 Gate Compiler & Studio (zero-CDN, single-file air-gapped HTML/JS).
    • Load the M365 Routing Guard (EX1550543) or Zero-Day Containment presets.
    • Drag S_dependency below 0.8000 in the live simulator to watch the gate transition from 200 ALLOW to 403 HARD HALT, then test a 15-minute commander-attributed Break-Glass token.
    • Click Export ServiceNow Bundle (.ZIP) to download a ready-to-install ServiceNow package with pre-computed 10⁻⁴ integer sys_properties and your pinned anchor_sha256 digest.
  2. Inspect the Source & Specifications:

VITI Labs conducts independent, empirical research into deterministic runtime governance, operational resilience, and zero-trust automation boundaries. All software artifacts are dual-licensed under AGPL-3.0 and Commercial Enterprise terms.

just google it: big framework erkki laine

Top comments (0)