Not an AI interface.
A transaction system.
CAIBots is a Policy-Constrained Autonomous Transaction System — architecturally closer to high-frequency trading infrastructure than to an AI assistant. Five planes. Closed execution loop. Hard policy enforcement. Deterministic, auditable writes to production systems of record — in Financial Services, Capital Markets, and Healthcare.
The law is enforced by architecture — not by discipline, not by configuration, not by documentation.
Five planes. One loop.
Zero ambiguity.
The animated flow shows how every execution moves through the system: Intent enters, Intelligence decides, the Policy Gate approves or blocks, Execution writes, Validation confirms, and the State Plane records everything — in a closed loop.
The system in
precise form.
The architectural guarantees can be expressed formally. For regulated enterprises, this matters: it means every execution variable is logged, every constraint is verifiable, and every examiner question has a deterministic answer.
What each plane owns.
What it cannot touch.
The architectural constraints are as important as the capabilities. Planes with hard boundaries produce systems that are auditable, debuggable, and governable. Planes that bleed into each other produce systems that are none of those things.
The Control Plane wraps every execution in the system. It is the implementation of the governance matrix: compliance rules, risk thresholds, regulatory constraints, and business policies encoded as executable logic. The Policy Engine operates on versioned, timestamped rules — every execution is evaluated against a specific policy version, and that version is logged in the audit record. The HITL Orchestration component manages human-in-the-loop gates: which execution categories require human approval, who is authorized to approve, what the SLA is, and what happens when the SLA expires.
The Intelligence Plane is a hybrid: probabilistic reasoning (LLM inference, classification, extraction) and deterministic decision logic (rules engines, decision tables, thresholds). The critical architectural constraint is that LLMs in this plane produce candidate decisions — they never trigger execution. Candidate decisions are passed to the Control Plane's Policy Engine, which applies the governance matrix before any execution proceeds. Decision Freezing ensures that non-deterministic LLM outputs are snapshotted at the moment of decision — making the reasoning trace reproducible and auditable, regardless of subsequent LLM behavior.
The Coordination Plane is a stateful, event-driven execution graph engine — not a "workflow tool". It receives an approved execution plan from the Control Plane and sequences it as a directed acyclic graph (DAG): step dependencies, retry policies, compensation workflows for partial failure, timeout handling with deterministic fallback states, and HITL gate insertion points. Every node in the DAG, every state transition, and every compensation event is logged. The execution plan is an auditable artifact — not a black box that ran and completed.
The Execution Plane is a transaction processor. It receives sequenced instructions from the Coordination Plane and executes system writes: Salesforce records, SAP entries, Oracle fields, Epic EMR updates, regulatory portal submissions. Every write is idempotent (safe to retry without duplicate state changes), tagged with execution_id, trace_id, and policy_hash, and confirmed before the next step proceeds. Rollback capability is maintained for the full execution lifetime — and rollback itself generates its own audit trail. The Execution Plane does not reason about what to write. It executes what it receives.
The State Plane is not a separate runtime — it is the persistent substrate that makes the system a closed loop rather than a one-way pipeline. All planes draw from and write to the State Plane: system state, event streams, context memory, decision snapshots, policy versions, and the execution ledger. Without the State Plane, CAIBots is a sophisticated pipeline. With it, the system is adaptive, reconstructable, and examiner-ready at any moment.
What each plane
cannot do.
The constraints are as important as the capabilities. Planes that violate these boundaries produce systems that are non-auditable, non-governable, and non-debuggable — which is why every boundary in the table below is enforced by the architecture, not by convention.
| Capability | Control | Intelligence | Coordination | Execution | State |
|---|---|---|---|---|---|
| Block or halt execution | ✓ Only plane | ✗ | ✗ | ✗ | ✗ |
| Write to systems of record | ✗ | ✗ | ✗ | ✓ Only plane | ✗ |
| Reason and make decisions | Policy only | ✓ | ✗ | ✗ | ✗ |
| Sequence execution steps | ✗ | ✗ | ✓ | ✗ | ✗ |
| Trigger HITL approval gate | ✓ Only plane | Flags only | ✗ | ✗ | ✗ |
| Generate audit records | ✓ Policy events | ✓ Decision trace | ✓ Plan + transitions | ✓ Every write | ✓ All state events |
| Access persistent memory | Policy store | ✓ Full | Plan state only | Write confirm | ✓ Full |
| Update its own rules in-flight | ✗ Never | ✗ Never | ✗ | ✗ | ✗ |
| Be bypassed by another plane | ✗ Never | Replaceable | Replaceable | Connector-level | Swappable |
CAIBots vs RPA vs AI Copilot
vs Workflow Automation.
The architecture comparison answers the question every CTO asks: "We already have UiPath/ServiceNow/Copilot — why is this different?" The answer is structural, not a matter of degree.
| Architectural Property | CAIBots | RPA (UiPath) | AI Copilot | Workflow (ServiceNow) |
|---|---|---|---|---|
| Execution type | Native API writes — direct to SOR | Screen automation / UI scraping | Recommendations only — human executes | Workflow routing — human approves each step |
| Governance enforcement | Architecture-level — cannot be bypassed | Bot-level config — bypassable | None — output is unstructured text | Workflow config — bypassable |
| Audit trail | Immutable per-execution ledger with decision rationale | Activity logs — no decision rationale | Chat history — not execution record | Workflow history — no AI reasoning trace |
| AI reasoning included | Intelligence Plane — domain-aware, policy-constrained | None — rule-based execution only | Yes — but no execution layer | Limited — routing rules only |
| Human-in-the-loop gates | Configurable per execution category — architecture enforced | Exception-based — not configurable by execution type | Human is always in the loop — by definition | Yes — but no AI decision upstream |
| Partial failure handling | Compensation workflows — structured rollback across systems | Manual remediation — no compensation logic | N/A — no execution to fail | Retry — no cross-system compensation |
| SR 11-7 / MiFID II / HIPAA native | Compliance frameworks encoded in Control Plane from day one | Configurable — requires significant compliance work | Not applicable — no execution layer | GRC module available — separate configuration |
| Production timeline | <90 days — guaranteed | 3–12 months — dependent on process complexity | Immediate — no integration required | 6–18 months — implementation-heavy |
The same architecture executing
across all three verticals.
Every execution follows the same five-plane loop regardless of vertical. These are production execution traces — showing exactly which plane handles which step, what system receives the write, what the policy gate evaluates, and what the validation engine confirms.
Five failure modes
solved by architecture.
Enterprise AI systems fail in production for predictable reasons. These are not edge cases — they are the five categories every regulated environment will eventually encounter. The architecture has a structural answer to each.
Native API participants.
Not middleware wrappers.
Every connector is a first-class API participant in the target system — authentication, field-level access, write confirmation, and execution tagging. No browser automation. No RPA screen scraping. No middleware translation layer.
See the five planes
executing in your systems.
30-minute technical session. We walk through integration with your specific systems of record, demonstrate live writes with full audit trail, and scope the Control Plane governance matrix for your compliance framework — across your vertical.