pipeline all phase
Bpmn_process
Bpmn-Studioweb-practice
Cloud-Run
Debug-lteration
Studioweb-Practice
Cloud-local
09-Evidence
10-Architecture
slide board

Audisor — Deterministic Pipeline Processing

Inspiration

In enterprise environments, AI can propose configuration fixes in seconds — but proving that a specific result is safe, getting explicit human authority, and applying only that approved mutation remains the production bottleneck. We watched teams generate hundreds of remediation suggestions while the apply queue stayed frozen because no one could prove which exact output was safe to deploy.

The gap isn't intelligence — it's governance. We asked: what if Maestro could separate advisory reasoning from deterministic authority, ensuring AI never directly mutates production, while making the proof-and-approval cycle fast enough to keep pace with generation?

What it does

This implements an 8-stage governed pipeline that coordinates UiPath Maestro BPMN, Agent Builder, API Workflows, RPA, and Action Center:

Snapshot → Scan → Analysis → Pre-Simulation → Simulation → Inspection → Relay → Final Output

The system enforces a formal safety contract. For any proposed configuration change:

Advisory AI classifies the issue but carries zero mutation authority
Deterministic admission gates control whether simulation proceeds — if confidence score $C < 93.91\%$, the change is rejected or isolated
Simulation executes in an isolated sandbox with cryptographic hashing
Inspection verifies convergence between simulated and expected states
Human decision (via Action Center) is the sole Apply authority — bound to exact result ID, hash, and target
Apply relay reproduces only the approved result — nothing more
Post-apply verification detects drift without silent repair

The admission threshold is computed deterministically:

$$T = \left\lfloor C \times 100 + 0.5 \right\rfloor \geq 9391$$

where $C$ is the weighted confidence score from code graders and information completeness checks. This integer-hundredths comparison eliminates floating-point ambiguity across platforms.

How we built it

Architecture: Maestro BPMN owns progression and gateways. Python handles the deterministic pipeline engine (phase controller, state machine, execution tracer). Each phase produces required outputs validated against JSON Schema contracts before advancement is permitted.

Key design decisions:

Phase Controller enforces strict sequential ordering — no phase can execute out of sequence
Isolation Engine runs an A/B comparison (isolation-on vs isolation-off) to prove research value
Execution Tracer captures intent-before and result-after for every phase, creating self-documenting proof-of-work
All path resolution uses Path(__file__).resolve().parent — zero hardcoded paths, portable across machines

Stack: Python 3.11, Pydantic models for all data contracts, UiPath Maestro BPMN for orchestration, JSON Schema (Draft 2020-12) for contract validation, Hypothesis for property-based testing.

Evidence production: Every pipeline run produces a cryptographically-stamped execution trace in proof/ — each trace contains the full narrative of what was attempted, what succeeded, what failed, and the SHA-256 hashes proving immutability.

Challenges we faced

BPMN binding without cloud access. We designed NextFlow-RealCase.bpmn with explicit BIND REQUIRED markers for Agent Builder, API Workflows, and Action Center — documenting exactly what needs binding rather than faking operational status.
Deterministic scoring across platforms. Floating-point comparison of confidence thresholds produced different results on different machines. We solved this by converting to integer hundredths using Decimal with explicit ROUND_HALF_UP — eliminating cross-platform ambiguity entirely.
Path independence for migration. The pipeline was originally developed in a workbench repository with dozens of hardcoded absolute paths. We abstracted all path resolution to Path(__file__).resolve() relative navigation, making the entire pipeline portable without configuration.
Proving determinism. Running the same input twice must produce the same snapshot hash. We validated this across overlapping, duplicate, and mixed-severity fixtures — 6 different fixture types, all producing consistent results.

What we learned

Separating "advisory reasoning" from "mutation authority" is the key architectural insight. AI should describe and classify; deterministic gates should admit; humans should authorize.
BPMN is powerful for expressing governance workflows — the visual structure makes the safety contract auditable by non-engineers.
Property-based testing (Hypothesis) found edge cases we never would have written manually — particularly around admission threshold boundaries and isolation convergence.
Execution traces are more valuable than logs. A structured narrative of intent → action → result → evidence creates auditable proof that satisfies compliance teams.