Prism

PRISM — Governance-Native Agents-as-a-Service Runtime

The first open-source agent platform with cryptographically enforced governance, tri-model cognitive orchestration, and full computer-use autonomy — designed for operators who refuse to choose between power and accountability.

PRISM is not another chatbot wrapper. It is a production-grade autonomous agent operating system that orchestrates LLM reasoning, browser automation, terminal virtualization, container sandboxing, and multi-agent swarms — all governed by an immutable policy engine with cryptographic integrity verification at boot and runtime.

Where other platforms bolt on safety as an afterthought, PRISM makes governance load-bearing architecture: every tool invocation, every agent decision, every autonomous action passes through a 3-tier policy engine before execution. High-risk operations require explicit human approval. Denials and timeouts are first-class tested behaviors. The operator is always supreme.

> "PRISM doesn't just run agents — it runs them with honor."

---

Why PRISM

The Problem

Every agentic framework today asks you to make the same trade-off: power or safety, autonomy or control, speed or transparency. The result is platforms that are either too constrained to be useful or too unconstrained to be trusted.

The PRISM Difference

PRISM eliminates that trade-off entirely through governance-native architecture — safety isn't a guardrail bolted onto the side; it's the foundation everything else is built on.

| Capability | Other Frameworks | PRISM | | :------------------ | :--------------------------------------- | :------------------------------------------------------------------------------------ | | Governance | Prompt-level guardrails, easily bypassed | Cryptographically enforced 10 Laws (SHA-256 integrity, CI-gated) | | Policy Engine | Basic allow/deny lists | 3-tier authority model with approval queues, timeouts, and denial paths | | Multi-Model | Single model per request | Spectrum Refraction: tri-model parallel fan-out with structured aggregation | | Computer Use | Browser-only or terminal-only | Full-stack: browser + terminal + container sandbox, all policy-governed | | Agent Lifecycle | Stateless tool calls | Managed lifecycles (ephemeral → semi-permanent → permanent) with swarm coordination | | Identity | API key auth | IAM with RBAC, SSO (OIDC/SAML), SCIM provisioning, character accountability chains | | Observability | Basic logging | SHA-256 hashed activity events, LLRE cognitive economics, retrieval quality telemetry | | Self-Hosting | Cloud-only or limited local | Fully self-hostable, runs on consumer hardware, your data never leaves your machine |

---

✦ Architecture at a Glance

┌──────────────────────────────────────────────────────────────┐
│                    OPERATOR DASHBOARD                        │
│  Chat │ Agents │ Browser │ Computer │ Network │ Telemetry    │
└──────────────────────────┬───────────────────────────────────┘
                           │
┌──────────────────────────▼───────────────────────────────────┐
│               GOVERNANCE PLANE                               │
│  ┌─────────┐  ┌──────────────┐  ┌──────────────────────┐    │
│  │ 10 Laws │  │ 3-Tier Policy│  │ Approval Queue       │    │
│  │ (PAD)   │──│ Engine       │──│ (tier2/tier3 gates)  │    │
│  │ SHA-256 │  │ auto│cond│apv│  │ approve/deny/timeout │    │
│  └─────────┘  └──────────────┘  └──────────────────────┘    │
└──────────────────────────┬───────────────────────────────────┘
                           │
┌──────────────────────────▼───────────────────────────────────┐
│              COGNITIVE RUNTIME                               │
│  ┌──────────┐ ┌──────────────┐ ┌─────────────────────┐      │
│  │ Spectrum │ │ Agent Pool   │ │ Skills Engine        │      │
│  │Refraction│ │ + Swarm Coord│ │ (Browser Researcher, │      │
│  │ (SR)     │ │ + Task Decomp│ │  Terminal, Calendar, │      │
│  │ 3-model  │ │ 4 topologies │ │  Email, Media, etc.) │      │
│  └──────────┘ └──────────────┘ └─────────────────────┘      │
│  ┌──────────┐ ┌──────────────┐ ┌─────────────────────┐      │
│  │ LLRE     │ │ Causal Memory│ │ Guardian Agent       │      │
│  │ Cognitive│ │ Fabric       │ │ (local llama.cpp,    │      │
│  │Economics │ │ (episodic +  │ │  autonomous health   │      │
│  │ TEQ/RSI  │ │  session +   │ │  monitor + PAD       │      │
│  │ CSR/TCA  │ │  semantic)   │ │  integrity checker)  │      │
│  └──────────┘ └──────────────┘ └─────────────────────┘      │
└──────────────────────────┬───────────────────────────────────┘
                           │
┌──────────────────────────▼───────────────────────────────────┐
│           TOOL ADAPTERS (Agent-Computer Interface)            │
│  System │ Protocol │ Application │ Network │ Cognition       │
│  Shell    HTTP       Browser       50+ cmds   SR Tool        │
│  FS       A2A        Terminal PTY  ipconfig    Autonomous     │
│  Docker              Container     ping        Planner        │
│  Images              Email/OAuth   tracert                    │
│  Audio               Calendar      netstat                    │
│  Video               Tasks/Notes   nslookup                   │
│  Screen              Media Gen                                │
└──────────────────────────────────────────────────────────────┘

---

✦ Novel Engineering

1. Permanent Active Directives (PAD) — Cryptographic Governance

PRISM's governance isn't configurable — it's constitutional. The 10 Laws (authored by Kirk LaSalle, rooted in Asimov's Three Laws and extended to cover privacy, equity, transparency, and operational boundaries) are cryptographically sealed:

• SHA-256 integrity verification at every boot and every 10 minutes by the Guardian Agent
• CI Gate blocks any merge/release where directives are modified without updating the integrity constant
• Machine-readable law manifest maps each directive to its runtime enforcement mechanism
• Governance preamble injection into all Tier 2+ LLM system prompts — every model interaction operates within the 10 Laws
• Amendment requires Governance Council approval + cryptographic re-signing

No other agent platform enforces governance at the cryptographic level.

2. Spectrum Refraction (SR) — Tri-Model Cognitive Orchestration

PRISM's novel compounding parallel fan-out architecture simultaneously engages three model instances:

| Hemisphere | Role | Example | | :--------------------- | :---------------------------------------- | :---------- | | Left (Logic) | Analytical reasoning, structured analysis | Claude Opus | | Right (Creative) | Creative generation, lateral thinking | GPT-4o | | Main (Coordinator) | Synthesis, arbitration, final response | Gemini Pro |

• Mandatory instance isolation: Left ≠ Right enforced at configuration, activation, and runtime gates
• Structured XML-tagged aggregation fuses analytical rigor with creative breadth
• Three isolation quality levels: full (different providers), model (same provider, different models), insufficient (rejected)
• Media artifact extraction from Creative hemisphere responses

No competing framework offers native multi-model simultaneous fan-out with structured aggregation and isolation enforcement.

3. LLRE Cognitive Economics Engine

The Low-Level Reasoning Engine provides unprecedented visibility into how efficiently your agents think:

• Token Efficacy Quotient (TEQ) — Are tokens being used effectively?
• Request Satisfaction Index (RSI) — Are user requests being fulfilled?
• Context Saturation Ratio (CSR) — Is context window capacity being optimized?
• Tool Call Accuracy (TCA) — Are tool invocations precise and successful?
• Prompt AST Compiler with ` and ` tag parsing and signal density checks
• SQLite persistence with interactive performance rings in the operator console

4. Full Computer Use — Browser, Terminal, Container

PRISM treats computer use as a first-class governed capability, not an auxiliary feature:

• Browser Automation — Playwright-powered headless and headed browser control with screenshot capture, page navigation, element interaction, and multi-tab management
• Terminal Virtualization — Real PTY sessions via node-pty with full shell access, command risk classification, and destructive-command deny lists
• Container Sandboxing — Docker container orchestration for isolated execution environments with resource limits and lifecycle management
• Autonomous Research — Browser Researcher skill that autonomously navigates, searches, extracts, and synthesizes information from the web
• All pathways governed by the 3-tier policy engine with approval gates for high-risk operations

5. Multi-Agent Swarm Orchestration

• Agent lifecycles: ephemeral (per-task), semi-permanent (idle-reaped), permanent (manual stop)
• Per-agent model assignment: dynamic provider/model override per agent, hot-swappable at runtime
• Four swarm topologies: mesh, star, pipeline, broadcast
• Task decomposition with dependency-aware parallel batch execution
• Intelligent telemetry: pattern detection, role hotspot analysis, lifecycle promotion recommendations
• Guardian Agent: permanent autonomous system agent powered by local llama.cpp inference — monitors runtime health, self-heals crashed model slots, enforces policy boundaries

6. Advanced Model Routing

• Fully Configurable & AI-Assisted: Complete operator control over routing topologies with AI assistance to dynamically determine the optimal model assignments based on task parameters.
• Role-Based Overrides: Map specific models or providers to individual task roles (e.g., chat, code-generation, summarization, memory indexing, or research) with automatic validation.
• Power-Aware Strategies: Supports routing strategies based on target profiles: eco (prioritizes local models to eliminate API charges), performance (highest available capability tier), and adaptive (balances VRAM and API costs dynamically).

7. Advanced Model Matrix (Exclusive Platform Core)

• Operator-Exclusive Registry: A dynamically updated, proprietary database of providers, models, use cases, capabilities, and attributes.
• Local Model Auto-Discovery: Automatically queries local runtime environments (e.g., Ollama /api/ps) to register and measure local capability parameters (VRAM, speed, parameter size).
• Deprecation & Sunset Lifecycle Tracking: Preserves deprecation dates, sunset deadlines, replacement successor patterns, and legacy telemetry configurations to prevent silent failures and preserve historical regression check capabilities.

8. Identity, Access & Accountability

• IAM Store with RBAC, multi-tenant support, and user lifecycle management
• SSO: OIDC and SAML integration for enterprise identity providers
• SCIM v2: Automated user provisioning and deprovisioning
• Character Accountability Control (CAC): every agent action linked to a character identity, a Prism user, and an operator via an immutable accountability chain
• Session management with cryptographic session tokens and cookie-based auth

9. Skills Engine — Autonomous Agent Capabilities

Production-ready skills that agents use to interact with the world:

| Skill | Capability | | :-------------------------- | :------------------------------------------------------------------------- | | Browser Researcher | Autonomous web research with search, navigation, extraction, and synthesis | | Terminal | Shell command execution with risk classification and deny lists | | Container Sandbox | Docker-based isolated execution environments | | Email (Gmail + Outlook) | OAuth2-authenticated email read/send via Google and Microsoft APIs | | Calendar | Google Calendar integration for event management | | Image Generation | AI image generation tool | | Audio/Video Generation | Media generation and transcription tools | | Tasks & Notes | Persistent task management and note-taking | | Project Store | Structured project data management with SQLite | | Semantic Query | Memory retrieval across episodic, session, and semantic stores |

10. Plugin Architecture — MCP + Marketplace

• Model Context Protocol (MCP) plugin system with hot-loading
• Ed25519 code signing for plugin integrity verification
• Plugin Pack Validator with manifest schema enforcement
• Marketplace curation policy with OSI license requirements
• Plugin toggle — enable/disable plugins at runtime without restart

11. Autonomic Update Engine & Guardian Integration

PRISM features a secure, operator-controlled, and autonomously monitored update orchestration framework integrated directly into the operator dashboard and the Guardian Agent's background cycle:

• Guardian-Assisted Update Detection: The Guardian Agent schedules periodic remote checks to query for update availability and alerts the operator on the console in real-time.
• One-Click Secure Execution: Operators can invoke updating via a single click in the sidebar, which spawns the out-of-process update orchestrator (scripts/prism-update.cjs).
• Safety First (Backup, Auditing, & Fallback):
• Automatically backs up all sensitive configuration databases, keys, and session data before downloading code.
• Executes a pre-flight system health audit using the PRISM Doctor suite to ensure baseline readiness.
• Automatically verifies download signature integrity and compile validity post-update.
• Auto-rolls back to the stashed backup if any compilation or startup test fails, protecting the instance from code corruption or dependency breakage.

12. Add-on Architecture — Deep System Integrations

PRISM introduces a new Add-on Layer sitting between the core system and the sandboxed Plugin SDK:

• UI & Subsystem Integration: Add-ons can mount custom dashboard tabs (such as the Robotics Entity console) and extend core system registries, memory systems, or database schemas.
• Certified Trust Model: Because Add-ons run outside the standard plugin sandbox, they require certified trust status — requiring manual operator enablement, cryptographic Ed25519 signature validation, and review against the 10 Laws.
• Domain-Specific Extensions: Perfect for deep integrations like external cognitive frameworks (UKS, BrainSim III), physical middleware (ROS 2), or high-throughput protocol bridges.

---

⚡ Quick Start

One Command (Windows)

start_web.bat

One Command (Linux / macOS)

chmod +x start_web.sh && ./start_web.sh

From Source

npm ci              # Install dependencies
npm run build       # Build (includes PAD integrity check)
npm run start:server   # Start dashboard at http://localhost:7070

With Docker

docker compose up -d    # Start with health checks and persistent volumes

With PM2 (auto-restart on crash)

npm install -g pm2
npm run p

…

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [kirklasalle](https://github.com/kirklasalle)
- **Source:** [kirklasalle/Prism](https://github.com/kirklasalle/Prism)
- **License:** Apache-2.0
- **Homepage:** https://www.youtube.com/@PrismRefractionAgent

Install and usage instructions live in the source repository linked above.