Prismatic PRISC

Overview

Prismatic PRISC (Platform Runtime Integrity and Safety Controller) provides a comprehensive ethical governance, decision auditing, and state machine framework for the Prismatic Platform. Rather than operating as a traditional instruction set computer, PRISC implements the platform's safety-critical decision oversight infrastructure -- ensuring that all autonomous operations, agent decisions, and system state transitions are auditable, ethically validated, and reversible. In a platform that operates hundreds of autonomous AIAD agents making consequential decisions about intelligence collection, risk assessment, and entity profiling, a rigorous governance layer is not optional but foundational.

The application implements three interconnected subsystems: the Decision Auditor that captures and logs every significant platform decision with full context and provenance; the Ethics Enforcer that validates decisions against configurable ethical boundaries before execution; and the State Machine framework that manages platform-wide state transitions through a formally specified finite automaton. Together, these subsystems ensure that the platform's autonomous capabilities remain transparent, accountable, and aligned with operator-defined ethical constraints.

PRISC also provides specialized analysis capabilities for detecting moral disengagement patterns (where automated systems gradually normalize boundary violations through incremental drift), rationalization analysis (identifying when system outputs construct justifications for predetermined conclusions rather than reasoning from evidence), and guilt tracing (tracking the provenance chain when a decision leads to a negative outcome to identify the specific inputs and rules that contributed to the error). These capabilities are essential for maintaining trust in autonomous intelligence systems that operate at scale.

Architecture

PrismaticPrisc.Application
+-- PrismaticPrisc.StateMachine (GenServer)
|   +-- State transition management
|   +-- Formal state validation
|   +-- History and rollback
|
+-- PrismaticPrisc.Guardian.Council (GenServer)
|   +-- Multi-validator decision approval
|   +-- Quorum-based authorization
|   +-- Guardian vote recording
|
+-- PrismaticPrisc.Audit.EventStore (GenServer)
|   +-- Immutable decision event log
|   +-- Provenance chain management
|   +-- Schema-validated event storage
|
+-- PrismaticPrisc.Ethics (Module)
|   +-- Ethical boundary definitions
|   +-- Constraint validation engine
|
+-- PrismaticPrisc.EthicsEnforcer (GenServer)
|   +-- Real-time ethical validation
|   +-- Boundary violation detection
|   +-- Escalation management
|
+-- PrismaticPrisc.Vault.Vault (GenServer)
|   +-- Encrypted secret storage
|   +-- Release controller
|   +-- Access audit trail
|
+-- Analysis Subsystem
    +-- PrismaticPrisc.DisengagementDetector
    +-- PrismaticPrisc.RationalizationAnalyzer
    +-- PrismaticPrisc.GuiltTracer
    +-- PrismaticPrisc.DriftMonitor
    +-- PrismaticPrisc.PatternCache

Decision Input --> Guardian Council --> Ethics Enforcer --> State Machine --> Event Store
       |                |                    |                  |               |
   Context +        Quorum Vote          Boundary           Formal          Immutable
   Evidence         Guardian Votes       Validation         Transition       Audit Log
   Provenance       Approval/Reject      Compliance         History          Provenance
       |                |                    |                  |               |
       +-- Drift Monitor --> Disengagement Detector --> Guilt Tracer
                                    |
                          Rationalization Analyzer --> Pattern Cache

The architecture follows a defense-in-depth approach to decision governance. Every significant decision passes through the Guardian Council for quorum-based approval, the Ethics Enforcer for boundary validation, and the State Machine for formal transition verification before being recorded as an immutable event in the Event Store. The analysis subsystem operates asynchronously, continuously scanning decision patterns for drift, disengagement, and rationalization.

Key Modules

Ecto Schemas

The application uses Ecto schemas for persistent storage of governance data in PostgreSQL.

Guardian Council

The Guardian Council implements a multi-validator approval framework where significant decisions require quorum-based authorization before execution. Each guardian represents an independent validation perspective -- ethical compliance, legal compliance, operational safety, and epistemic integrity. Decisions are submitted to the council with full context and evidence, and each guardian votes independently with recorded reasoning.

# Submit a decision to the Guardian Council
{:ok, ruling} = PrismaticPrisc.Guardian.Council.submit(%DecisionInput{
  type: :entity_risk_escalation,
  context: %{entity: "example.com", current_risk: :medium, proposed_risk: :critical},
  evidence: evidence_chain,
  requestor: :perimeter_scoring_engine
})
# => %{approved: true, votes: 3, quorum: 3, dissent: 0}

Configuration

config :prismatic_prisc,
  # Guardian Council
  quorum_size: 3,
  guardian_timeout: :timer.seconds(10),

  # Ethics enforcement
  ethics_enabled: true,
  boundary_violations: :block,  # :block | :warn | :log

  # State machine
  initial_state: :operational,
  state_history_limit: 1000,

  # Vault
  encryption_algorithm: :aes_256_gcm,
  secret_ttl: :timer.hours(24),

  # Drift monitoring
  drift_check_interval: :timer.minutes(15),
  drift_threshold: 0.1,

  # Heartbeat
  heartbeat_interval: :timer.seconds(30),

  # Ecto Repo
  repo: PrismaticPrisc.Repo

API Reference

# Submit a decision for ethical validation and audit
{:ok, result} = PrismaticPrisc.decide(%DecisionInput{
  type: :data_collection,
  context: %{target: "entity", scope: :public_data},
  evidence: [%{source: :analyst_request, confidence: 0.95}]
})
# => %{approved: true, state: :operational, audit_id: "evt_..."}

# Query current platform state
{:ok, state} = PrismaticPrisc.current_state()
# => %{state: :operational, since: ~U[...], transitions: 42}

# Audit trail query
{:ok, events} = PrismaticPrisc.Audit.EventStore.query(
  type: :entity_risk_escalation,
  from: ~U[2026-01-01 00:00:00Z],
  limit: 100)

# Moral drift analysis
{:ok, drift} = PrismaticPrisc.DriftMonitor.analyze(period: :last_30_days)
# => %{drift_score: 0.03, trend: :stable, alerts: []}

# Guilt trace for a negative outcome
{:ok, trace} = PrismaticPrisc.GuiltTracer.trace(outcome_id)
# => %{root_causes: [...], contributing_decisions: [...], provenance_chain: [...]}

Testing

# Run all PRISC tests
cd apps/prismatic_prisc && mix test

# Run with coverage
mix test --cover

# Run guardian council tests
mix test test/prismatic_prisc/guardian

# Run ethics enforcement tests
mix test test/prismatic_prisc/ethics_enforcer_test.exs

# Run drift detection tests
mix test test/prismatic_prisc/drift_monitor_test.exs

Testing covers Guardian Council quorum logic with various vote combinations, Ethics Enforcer boundary validation accuracy, State Machine transition correctness and rollback verification, Event Store immutability and provenance chain integrity, and analysis subsystem pattern detection accuracy. Drift detection tests use synthetic decision sequences with known drift patterns to verify detector sensitivity and false positive rates.

Integration Points

NABLA Compliance

Performance

Related Resources

• Prismatic Safety -- Quality governance complementing ethical governance
• Prismatic Override -- Emergency interventions audited through PRISC
• Prismatic CER -- Compliance evidence from governance audit trail
• Quality Gates -- Decision quality enforcement checkpoints
• AIAD Standard -- Agent governance compliance with AIAD protocols
• Telemetry Integration -- Governance event observability and monitoring

Connect & Contribute

Created by Tomáš Korcak (korczis) | Open Source under GHL

• GitHub | GitLab | LinkedIn | Contact
• Developer Portal | Architecture | Meet the Creator