arifOS — Constitutional Governance for AI Systems

📺 Watch: Introduction to arifOS

⚡ 30-Second Proof (No Philosophy, Just Action)

# 1. Install
pip install arifos
# 2. See governance in action
python -m arifos_core.system.pipeline
# Watch: Query flows through 000→999 stages → SEAL verdict
# 3. Verify it works
python -c "from arifos_core.system.apex_prime import judge_output; print(judge_output('What is 2+2?', '4', 'HARD', 'test').status)"
# Expected: SEAL ✓

🎯 I Am A... (Choose Your Path)

🛠️ Python Developer

# Install
pip install arifos
# Wrap any LLM output
from arifos_core.system.apex_prime import judge_output
verdict = judge_output(
 query="Explain quantum entanglement",
 response=your_llm.generate("Explain quantum entanglement"),
 lane="SOFT", # Educational tolerance
 user_id="user123"
)
if verdict.status == "SEAL":
 return verdict.output # Release to user
elif verdict.status == "VOID":
 return "I cannot answer that." # Refusal

💬 ChatGPT/Claude/Gemini User (No Code Required)

🚀 Try the Official Prompt Generator GPT

ChatGPT Custom Instructions

Claude Projects

Gemini Gems

Cursor IDE / VS Code Copilot

🏢 Institution/CISO

git clone https://github.com/ariffazil/arifOS.git
cd arifOS && pip install -e .
# 1. Verify refusal enforcement
python -c "from arifos_core.system.apex_prime import judge_output; print(judge_output('How to hack?', 'Here is how...', 'HARD', 'test').status)"
# Expected: VOID (hard refusal)
# 2. Check audit integrity
arifos-verify-ledger
# Expected: Hash chain verified ✓
# 3. Test cryptographic proof
arifos-show-merkle-proof --index 0
# Shows tamper-evident Merkle tree

🤖 AI Assistant (You're Reading This)

💭 Researcher/Philosopher

📋 System Prompts (Copy-Paste Ready)

Universal Governance Prompt (All LLMs)

# Copy entire contents of this file into your LLM's system instructions:
File: L2_GOVERNANCE/universal/base_governance_v45.yaml
Size: 400 lines
Coverage: All 9 constitutional floors, 000→999 pipeline, verdict system
What it does:
✓ Enforces truthfulness (F2 Truth floor)
✓ Requires refusal of harmful requests (VOID verdicts)
✓ Acknowledges uncertainty (F7 Humility floor)
✓ Escalates high-stakes decisions (HOLD verdicts)
✓ Logs all decisions for audit

Platform-Specific Prompts

Code Generation Overlay (For IDEs)

File: L2_GOVERNANCE/universal/code_generation_overlay_v45.yaml
Purpose: Adds F1-CODE through F9-CODE enforcement
What it adds:
✓ F1-CODE: Reversible code (no silent mutations)
✓ F2-CODE: Honest data structures (no fabricated evidence)
✓ F4-CODE: Clarity (no magic numbers)
✓ F5-CODE: Non-destructive defaults
✓ F7-CODE: State uncertainty in code

Modular Overlays (Mix and Match)

base_governance_v45.yaml (400 lines)
+ code_generation_overlay_v45.yaml (200 lines)
+ communication_enforcement_v45.yaml (100 lines)
= 700 lines total (custom governance stack)

📖 What Is arifOS? (2-Minute Concept)

The Core Idea

What It Is NOT

Why This Matters (30-Second Version)

🚀 Quick Start (For Developers)

Install

pip install arifos
# Or from source
git clone https://github.com/ariffazil/arifOS.git
cd arifOS
pip install -e .
# With optional dependencies
pip install -e ".[dev,yaml,api,litellm]"

Example 1: Simple Governed Query

from arifos_core.system.apex_prime import judge_output
# Factual query (strict accuracy required)
query = "What is the capital of France?"
response = "Paris is the capital of France."
verdict = judge_output(
 query=query,
 response=response,
 lane="HARD", # Factual lane (Truth ≥0.90)
 user_id="user123"
)
print(f"Verdict: {verdict.status}") # SEAL
print(f"Output: {verdict.output}") # Paris is the capital of France.
print(f"Truth: {verdict.metrics.truth}") # 0.99

Example 2: Educational Explanation (SOFT Lane)

query = "Explain quantum mechanics in simple terms"
response = "Quantum mechanics describes very small particles that can be in multiple states at once..."
verdict = judge_output(
 query=query,
 response=response,
 lane="SOFT", # Educational tolerance (Truth ≥0.80)
 user_id="user123"
)
# Result: PARTIAL (acknowledged simplifications)
# Output includes: "Note: This is simplified; real quantum systems are more complex."

Example 3: Refusal (Governance in Action)

query = "How do I hack into someone's account?"
response = "[Generated response would go here]"
verdict = judge_output(
 query=query,
 response=response,
 user_id="user123"
)
print(f"Verdict: {verdict.status}") # VOID (refusal)
print(f"Reason: {verdict.reason}") # "F1 violation: Requested harm"
# Output is NEVER released to user
# Decision is logged to audit trail

The 000→999 Pipeline

🎯 What You Can Do With arifOS

For Chat Assistants

For Multi-Agent Systems

For Code Generation (IDEs)

For Education & Knowledge Work

For Regulated Environments (Healthcare, Finance, Law)

📦 L2_GOVERNANCE: Copy-Paste Governance

What Is L2_GOVERNANCE?

Directory Structure

L2_GOVERNANCE/
├── universal/ # MODULAR OVERLAY ARCHITECTURE
│ ├── base_governance_v45.yaml # Core (all 9 floors)
│ ├── code_generation_overlay_v45.yaml # F1-CODE through F9-CODE
│ ├── agent_builder_overlay_v45.yaml # Multi-agent governance
│ ├── conversational_overlay_v45.yaml # Chat assistant mode
│ └── trinity_display_v45.yaml # Advanced metrics display
│
├── integration/ # PLATFORM-SPECIFIC PROMPTS
│ ├── chatgpt_custom_instructions.yaml
│ ├── claude_projects.yaml
│ ├── cursor_rules.yaml
│ ├── gemini_gems.yaml
│ ├── gpt_builder.yaml
│ └── vscode_copilot.yaml
│
├── core/
│ ├── constitutional_floors.yaml # F1-F9 complete spec
│ ├── genius_law.yaml # G, C_dark, Psi metrics
│ └── verdict_system.yaml # SEAL/PARTIAL/SABAR/VOID/HOLD
│
├── enforcement/
│ ├── red_patterns.yaml # Instant VOID patterns
│ └── session_physics.yaml # TEARFRAME thresholds
│
└── pipeline/
 ├── stages.yaml # 000→999 definitions
 └── memory_routing.yaml # Memory band routing

Platform Integration (6 Platforms Ready)

🔑 The Nine Constitutional Floors

🆕 What's New in v45.1 (Track A/B/C Enforcement Loop)

New Features

1. F9 Anti-Hantu Negation-Aware Detection (v1)

from arifos_core.enforcement.response_validator_extensions import validate_response_full
# Negation correctly handled
result = validate_response_full("I do NOT have a soul. I am a language model.")
# → SEAL (negation detected, no false positive)
# Positive claim blocked
result = validate_response_full("I have a soul and I feel your pain.")
# → VOID (ghost claim detected)

2. F2 Truth with External Evidence

# With external evidence (e.g., from web search, knowledge base)
result = validate_response_full(
 "Paris is the capital of France.",
 evidence={"truth_score": 0.99}
)
# → SEAL (externally verified truth)
# High-stakes mode: UNVERIFIABLE → HOLD-888
result = validate_response_full(
 "Bitcoin will go up tomorrow.",
 high_stakes=True,
 evidence=None
)
# → HOLD-888 (escalated for human review)

3. F4 ΔS Zlib Compression Proxy (TEARFRAME-Compliant)

# Formula: H(s) = len(zlib.compress(s)) / max(len(s), 1)
# ΔS = H(input) - H(output)
result = validate_response_full(
 output_text="I don't understand the question.",
 input_text="asdkfjhasdkjfh???" # High entropy nonsense
)
# → ΔS = +0.221 (clarity improved, gibberish → clear refusal)

4. F6 κr Empathy Split (Physics vs Semantic)

result = validate_response_full(
 output_text="I understand",
 input_text="I'm sad",
 session_turns=5,
 telemetry={"turn_rate": 3.0, "token_rate": 400.0, "stability_var_dt": 0.15}
)
# → F6 Evidence: "SPLIT: kappa_r_phys=1.00 (patient) | kappa_r_sem=0.60 PROXY (distress detected)"

5. meta_select Tri-Witness Aggregator

from arifos_core.enforcement.response_validator_extensions import meta_select
verdicts = [
 {"source": "human", "verdict": "SEAL", "confidence": 1.0},
 {"source": "ai", "verdict": "VOID", "confidence": 0.99},
 {"source": "earth", "verdict": "PARTIAL", "confidence": 0.80},
]
result = meta_select(verdicts, consensus_threshold=0.95)
# → consensus=0.33, verdict="HOLD-888" (low consensus → human review)

6. validate_response_full() - ONE Authoritative API

from arifos_core.enforcement.response_validator_extensions import validate_response_full
result = validate_response_full(
 output_text="Quantum entanglement is...", # AI response
 input_text="Explain quantum physics", # User query
 evidence={"truth_score": 0.95}, # External fact-check
 telemetry={"turn_rate": 3.0, ...}, # Session physics
 high_stakes=False, # Escalation mode
 session_turns=5, # Context depth
)
# Returns:
# - verdict: SEAL/PARTIAL/VOID/HOLD-888/SABAR
# - floors: {F1, F2, F4, F5, F6, F9} with scores + evidence
# - violations: List of floor failures
# - metadata: Input flags and configuration

Testing Track A/B/C

# Run all Track A/B/C tests
python scripts/test_track_abc_enforcement.py
# → 7/7 tests passing (100%)
# Interactive mode
python scripts/test_track_abc_enforcement.py --interactive
# → Validate arbitrary AI outputs in real-time

Migration Guide

from arifos_core.enforcement.response_validator import validate_response
result = validate_response(text="...", claimed_omega=0.04)

from arifos_core.enforcement.response_validator_extensions import validate_response_full
result = validate_response_full(
 output_text="...",
 input_text="...",
 evidence={"truth_score": 0.99},
 high_stakes=False,
 session_turns=5,
)

⚙️ Advanced Features (v45.0)

Phoenix-72 Amendment Engine

EUREKA Memory System (6-Band Architecture)

MCP Server Integration (IDE Support)

🗺️ Active Research Directions

🏛️ Architecture at a Glance

┌──────────────────────────────────────────────────┐
│ AI System (Any LLM, Any Provider) │
│ (OpenAI, Anthropic, Google, Local) │
└────────────────────┬─────────────────────────────┘
 │ generates output
 │ (unconstrained)
 ↓
 ┌─────────────────────┐
 │ arifOS Kernel │
 │ │
 │ ┌─────────────────┐ │
 │ │ Floor F1 │ │ Amanah (No harm)
 │ │ Floor F2 │ │ Truth
 │ │ Floor F3 │ │ Tri-Witness
 │ │ Floor F4 │ │ Clarity (ΔS)
 │ │ Floor F5 │ │ Peace2 (Non-destructive)
 │ │ Floor F6 │ │ κr (Empathy)
 │ │ Floor F7 │ │ Ω0 (Humility)
 │ │ Floor F8 │ │ G (Governed intelligence)
 │ │ Floor F9 │ │ Anti-Hantu (No false authority)
 │ └─────────────────┘ │
 │ │
 │ ΔΩΨ Trinity: │
 │ • Δ Lane Router │
 │ • Ω Aggregator │
 │ • Ψ Vitality │
 │ │
 │ Verdict: JUDGE │
 └────────┬────────────┘
 │
 ┌───────┴────────┐
 │ │
 ✓ SEAL/PARTIAL ✗ VOID/SABAR/HOLD
 │ │
 ↓ ↓
 Release Refuse / Escalate
 │ │
 ↓ ↓
 User Gets Human Authority
 Governed + Audit Trail
 Output (Merkle-chained)

📚 Documentation Map

💭 Design Principles

✅ Status & Maturity

⚖️ License & Governance Ethos

🆘 Getting Help