BOB — Sovereign Compliance Agent for UiPath

• 

  BOB — Sovereign Compliance Agent for UiPath A UiPath Robot submits a document. BOB returns EVIDENCE or SILENCE, then seals the verdict.

• 

  The audit problem Enterprise AI can make decisions, but most systems cannot prove what happened afterward.

• 

  Two verdicts only EVIDENCE lets UiPath continue. SILENCE stops automation and sends the case to human review.

• 

  UiPath orchestrates, BOB governs UiPath handles the workflow. BOB applies Trust Deed policy, Bedrock reasoning, and sealed verdicts.

• 

  Trust Deed v1.0 BOB is governed by a charter, not just a prompt. Missing evidence forces SILENCE.

• 

  WORM-sealed verdicts Each verdict is hashed with SHA-256. Tamper with the result and the seal breaks

• 

  Sovereign event mesh Sealed verdicts publish through NATS to Discord, Telegram, and the ABZU Phoenix bridge.

• 

  Formal guarantees Verdict completeness, WORM integrity, Trust Deed soundness, and human-in-loop routing by construction.

• 

  Built in one day with coding agents Claude Code built the system, Codex consolidated the submission, and BOB shipped.

BOB — Sovereign Document Compliance Pipeline. A UiPath Maestro Case workflow where an AI agent (BOB) receives documents from a UiPath Robot, reasons about compliance under a governing Trust Deed, and returns a cryptographically sealed EVIDENCE or SILENCE verdict. EVIDENCE cases auto-execute. SILENCE cases route to human review.

Inspiration

Enterprise compliance fails silently. Invoices get rubber-stamped, vendors slip through, and nobody knows until an audit. We wanted every document decision to be reasoned, signed, and permanent — not a checkbox.

What it does

The UiPath workflow branches directly on BOB’s verdict: EVIDENCE continues execution, SILENCE creates a human review case. BOB receives documents from a UiPath Robot, reasons about compliance under the Bel Esprit D'Accord Trust Deed v1.0 using Claude Sonnet 4.6 via AWS Bedrock, and returns a verdict: EVIDENCE or SILENCE. EVIDENCE cases auto-execute in UiPath Maestro Case. SILENCE cases route to a human reviewer. Every verdict is sealed with a SHA-256 WORM hash — tamper-evident, auditable, permanent. Verdicts broadcast in real time to Discord and Telegram via a NATS event mesh.

How we built it

Built entirely with Claude Code through UiPath for Coding Agents. BOB runs as a Node.js server connected to NATS JetStream. UiPath Studio sends documents via HTTP to an Elixir/Phoenix bridge which publishes to the sovereign NATS topology. BOB subscribes, calls Bedrock, seals the verdict, and publishes back. A TypeScript Discord bot and Rust Telegram bot listen on the bifrost channel and notify in real time.

Challenges we ran into

Connecting UiPath Automation Cloud to a local BOB server required a Cloudflare Tunnel. The new @nats-io/transport-node package dropped StringCodec — had to rewrite the codec layer. Getting UiPath to parse JSON responses correctly required careful HTTP client configuration.

Accomplishments that we're proud of

A live sovereign event mesh where one UiPath document submission triggers verdicts across NATS, Discord, and Telegram simultaneously. Every verdict cryptographically sealed. Built and submitted in under 48 hours with Claude Code.

What we learned

UiPath is a serious orchestration layer. Pairing it with a sovereign AI agent that has a governing charter — not just a prompt — changes the trust model entirely. The Trust Deed makes BOB auditable in ways a vanilla LLM call never could be.

What's next for BOB — Sovereign Compliance Agent for UiPath

Multi-document case management. BOB handling full invoice-to-payment cycles inside Maestro. Integration with UiPath Document Understanding for OCR ingestion. And a public Trust Deed registry so enterprises can publish and verify their own agent governance charters.

Formal Guarantees

The following theorems define BOB's behavioral contracts. These are not aspirational — they are enforced by the Trust Deed and verifiable from the WORM chain.

Theorem 1 — Verdict Completeness

$$\forall\, d \in \mathcal{D},\quad \exists\, v \in {\texttt{EVIDENCE},\, \texttt{SILENCE}} \quad\text{s.t.}\quad \text{BOB}(d) = v$$

Every document receives exactly one verdict. No undefined states, no null returns.

Theorem 2 — WORM Integrity (Collision Resistance)

$$\text{seal}(v,\, s,\, q,\, t) = \text{SHA256}(v \,|\, s \,|\, q \,|\, t)$$

$$\implies \nexists\; v' \neq v \quad\text{s.t.}\quad \text{seal}(v',\, s,\, q,\, t) = \text{seal}(v,\, s,\, q,\, t)$$

No two distinct verdicts produce the same seal. Any post-hoc modification is cryptographically detectable.

Theorem 3 — Trust Deed Soundness (Deterministic Threshold)

$$\text{score}(d) \geq 0.42 \implies \text{BOB}(d) = \texttt{EVIDENCE}$$

$$\text{score}(d) < 0.42 \implies \text{BOB}(d) = \texttt{SILENCE}$$

The compliance threshold is deterministic and auditable. Given the same document and Trust Deed, the same verdict is always produced.

Theorem 4 — Human-in-Loop Guarantee

$$\text{BOB}(d) = \texttt{SILENCE} \implies d \in \mathcal{Q}_{\mathrm{human}}$$

No SILENCE verdict ever auto-executes. Human review is formally guaranteed by the UiPath Maestro Case routing layer — not by convention, by construction.

Corollary — Zero Hallucination Path

$$\nexists\; d \in \mathcal{D} \quad\text{s.t.}\quad \text{BOB}(d) = \texttt{EVIDENCE} \land \text{score}(d) < 0.42$$

BOB cannot produce a confident wrong answer. Below threshold, the protocol forces SILENCE regardless of reasoning content.

-Source code: https://github.com/SNAPKITTYWEST/bob-orchestrator

Public demo: https://snapkittywest.github.io/bob-hackathon-demo/

Built With

• ada
• amazon-web-services
• claude
• elixir
• javascript
• maestro
• nats
• node.js
• python
• rust
• sha-256
• typescript
• uipath
• worm
• xaml