SCIA Reference Architecture

ARQUA · Pre-Execution Pressure Test · Reference Architecture · Sectors · Why Architecture First · Architecture in Practice · About Arqua · Request a Briefing

SCIA Reference Architecture

Execution Admissibility Architecture for Institutional Systems

SCIA — Stateful Contextual Integrity Architecture

SCIA is a control architecture that governs whether proposed state transitions are permitted to bind institutional consequence, by enforcing admissibility at the point of execution.

SCIA sits at the execution commit boundary, where institutional consequence becomes binding.

Sovereignty

Sovereignty defines which constraints are binding and who has the authority to enforce them at execution.

In SCIA:

• sovereignty is explicitly declared
• authority is resolved from sovereignty at runtime
• execution is permitted only within that authority context

SCIA evaluates admissibility at runtime and enforces execution at the commit boundary.

Decision systems propose candidate actions at scale.

SCIA governs whether the corresponding state transition is permitted to execute.

Execution systems bind institutional consequence by mutating state.

Patent Status

Elements of the SCIA architecture and the execution admissibility control model are the subject of a patent-pending filing.

The architectural concepts described here are shared publicly to define the category of Execution Admissibility Architecture while the underlying methods and implementation structures remain protected intellectual property.

Category Definition

SCIA evaluates admissibility at runtime and enforces execution at the commit boundary.

It sits at the commit boundary of consequence, where an automated or human-initiated action would otherwise become an institutional commitment.

SCIA governs state transitions. It does not govern decisions.

It ensures that execution is not triggered by intent alone.

The Institutional Problem

The enterprise does not fail at decisioning. It fails at execution.

Enterprises separate decision generation from execution.

Decision systems propose candidate actions.

Semantic layers define what entities, obligations, and states mean.

Without a governed commit boundary, intent and recommendation can trigger consequence.

Execution without admissibility creates institutional risk.

That risk appears at the moment a transition becomes irreversible or externally consequential: a payment is sent, a contract is issued, an access right is granted, an infrastructure change is applied, or a regulatory submission is lodged.

Integrated Architecture Overview

Execution requires a governed transition from meaning to consequence.

Institutional systems require an end-to-end execution control chain, not a stronger decision engine.

This diagram shows how actions move from proposal to governed execution.

Proposal → meaning → decision → commit boundary → control plane → execution → consequence.

Proposal Sources

Humans, agents, workflows, and external systems that initiate proposed actions.

Semantic / Meaning Substrate

Shared definitions of entities, obligations, state, and context.

Decision Systems (Candidate Decisions)

Models, rules, and decision services that output candidate actions.

Execution Commit Boundary

Non-bypassable enforcement surface where consequence would bind.

SCIA Control Plane

Internal SCIA evaluation system.

Execution Systems

Enterprise systems that execute real operations and mutate state.

Institutional Consequence

Financial, legal, operational, or regulatory commitment created by execution.

Semantic and Decision Integration

Meaning, decision, and execution must be separated to be governed.

Meaning binds reality. Decision proposes change.

Semantic = meaning

The semantic substrate defines what entities, obligations, states, and evidence mean.

Decision = proposal

Decision systems output candidate actions. Outputs remain proposals.

SCIA = admissibility at execution

SCIA re-resolves admissibility at runtime and enforces the outcome at the commit boundary.

👉 Meaning must bind before admissibility is computed.

This diagram separates meaning, decision, and execution so they can be governed.

Diagram — Semantic → Decision → Commit

Meaning binds before admissibility is computed.

Constraint Compilation Layer

Meaning must become executable before it can be enforced.

Ambiguity cannot cross the commit boundary.

Semantic meaning compiles into machine-evaluable constraints.

This makes admissibility deterministic and enforceable at runtime.

👉 SCIA compiles meaning into constraints before evaluating admissibility.

Diagram — Meaning → Constraint → Admissibility

Meaning becomes executable constraint for runtime evaluation.

SCIA Control Plane

Admissibility is evaluated at the moment an action would bind institutional consequence.

SCIA re-resolves admissibility at runtime and enforces the outcome at the commit boundary.

The evaluation is deterministic, traceable, and enforceable.

Authority (who can act)

Decision rights, delegation, mandated scope.

Evidence (what supports the action)

Required evidence exists, is current, and is bound to the action and context.

Context (when/where/conditions)

Operating conditions: timing, environment, risk posture, dependencies.

Constraints (rules, policy, limits)

Policy rules, invariants, and limits as enforceable conditions.

State (eligibility to transition)

Relevant institutional state is eligible for the proposed transition.

SCIA ensures that system state can only move forward if its integrity can be proven at the moment of execution.

This diagram shows how admissibility is evaluated at runtime.

Diagram — Control Plane Detail

Internal SCIA evaluation system.

Control plane components

Execution Commit Boundary

The execution commit boundary is the non-bypassable enforcement point where institutional consequence becomes binding.

Execution does not proceed without admissibility.

SCIA enforces execution at this surface.

Diagram — Execution Commit Boundary

All consequence-binding actions must pass through this boundary.

Typed Admissibility Outcomes

SCIA evaluates admissibility at runtime and produces typed outcomes.

The core outcomes are:

• ADMISSIBLE
• ADMISSIBLE_WITH_CONDITIONS
• ESCALATE
• NOT_ADMISSIBLE
• INSUFFICIENT_INFORMATION

Relationship to Architecture of Record (AoR)

AoR defines where consequence binds. SCIA enforces execution at the commit boundary.

AoR identifies where institutional consequence binds across the enterprise.

SCIA enforces execution at the commit boundary across those consequence surfaces.

Diagram — AoR ↔ SCIA Relationship

AoR surfaces identify bind points; SCIA enforces execution at the commit boundary.

Example Execution Domains

SCIA applies wherever execution binds institutional consequence.

Common execution domains:

• Payments
• Contracts
• Infrastructure changes
• Regulatory submissions
• Entitlements / access control

Across these domains, the pattern holds: decision proposes, admissibility is evaluated at execution, execution is enforced, consequence binds.

Positioning Statement

SCIA is NOT:

• a product
• a policy engine
• a rules system

SCIA IS:

• an execution admissibility architecture
• a control plane for institutional action
• a runtime integrity gate for consequence-bearing state transitions

SCIA defines the architectural control model through which enterprises govern consequence-binding execution.

Explore the Architecture

• Category Overview
• Overview of Execution Admissibility Architecture.
• Execution Admissibility Architecture — Architecture Map
• The architecture layers and how they relate.
• Execution Admissibility Architecture
• The architectural discipline governing admissible execution.
• Architecture of Record (AoR)
• The structural map of institutional consequence across the enterprise.
• SCIA Reference Architecture
• The reference architecture that enforces admissibility at execution.
• Pre-Execution Pressure Test
• Diagnostic that surfaces execution risk before consequence binds.

Patent notice

Certain elements of the SCIA reference architecture are the subject of patent-pending protection.

Final Statement

Execution is not governed by intent.

It is governed by admissibility at the point of commit.

SCIA defines the architecture that makes admissible execution enforceable.

👉 Intelligence may propose. Only admissible execution may bind.

© Arqua Pty Ltd. All rights reserved.