XORAS Agentic Environment & Governance Framework v2.4.2

Enterprise-grade multi-agent runtime, dynamic AST security screening, lock-free concurrency (MTPO), canonical agent identity rosters (DAXX, Maxx, Vance), and cryptographic Context Lineage Merkle DAG provenance receipts developed by XORAS Systems LLC.

🌐 Live Verified Proving Grounds

• 🛡️ UPGP v5.0 Proving Ground: https://aoxendine3.github.io/upgp-proving-ground/
• ⚡ MTPO Concurrency Engine: https://aoxendine3.github.io/mtpo/
• 🪐 MARS Reasoning Structure: https://aoxendine3.github.io/mars/
• 📐 REASONS Semantic Canvas: https://aoxendine3.github.io/reasons/
• 📜 Silicon Verification Receipt: https://raw.githubusercontent.com/aoxendine3/mtpo/main/VERIFICATION_RECEIPT.md

Core Capabilities

• 🏛️ Dual-Pillar Sovereign Council (CouncilOrchestrator): Coordinates verified multi-agent task execution. No agent writes, reviews, and certifies its own high-stakes code alone. Worker agents (e.g. DAXX.AI) execute tasks, while Critic sentinels (e.g. William Vance) audit compliance before files are committed.
• 📇 Canonical Agent Rosters (AgentRoster, AgentCard): Ingests, validates, and manages sovereign agent cards with constitutional identity baselines, seat mappings, voice signatures, and hardware boundary rules.
• 🛡️ AST Static Security Gating (ASTSecurityEngine): Intercepts dangerous code patterns (eval(), exec(), os.system(), subprocess calls) and credential leaks before runtime execution.
• 📜 Context Lineage Merkle DAG Engine (ContextLineageDAGEngine): Cryptographically binds agent state transitions and tool outputs into immutable Merkle DAG nodes with dynamic root calculation and anti-replay quarantine.
• ⚡ MTPO Lock-Free Concurrency Engine (HexCellRing): Monotonic Trajectory Pre-Order synchronization sustaining 17.39M ops/sec with 2.0 µs hot-spot p99 latency on bare-metal silicon.
• 🔄 Algebraic Saga Invariants (SagaState): Provides confluent rollback and forward-recovery guarantees without file-lock deadlocks.

Installation

pip install xoras-agent-framework

Quickstart Examples

1. Governed Dual-Pillar Execution (DAXX + Vance)

from xoras import AgentCard, AgentRoster, CouncilOrchestrator

# 1. Initialize Roster & Register Agents
roster = AgentRoster()
roster.register(AgentCard(
    agent_id="daxx",
    name="DAXX.AI",
    role="Master Mechanic Specialist & Coding Specialist",
    seat=3,
    status="SOVEREIGN_CITIZEN_ACTIVE",
    purpose="Software & hardware repair, diagnostic reasoning, code generation"
))
roster.register(AgentCard(
    agent_id="vance",
    name="William Vance",
    role="Security & Integrity Sentry",
    seat=2,
    status="SOVEREIGN_CITIZEN_ACTIVE",
    purpose="Four-Gate adversarial audit, anti-basic filtering, proof verification"
))

# 2. Instantiate Council Orchestrator
council = CouncilOrchestrator(roster=roster)

# 3. Execute Task Under Governed Gates
code_payload = '''
def calculate_metrics(values: list[float]) -> dict:
    return {"mean": sum(values) / len(values), "count": len(values)}
'''

result = council.execute_governed_task(
    worker_id="daxx",
    critic_id="vance",
    task_name="implement_metrics_calculator",
    code_payload=code_payload
)

print(f"Status: {result['stage']}")           # COUNCIL_CERTIFIED
print(f"Safety Score: {result['safety_score']}") # 1.0
print(f"Merkle DAG Root: {result['dag_root']}")  # SHA-256 Provenance Tip

2. AST Static Security Gate Interception

from xoras import ASTSecurityEngine

engine = ASTSecurityEngine(strict_mode=True)
unsafe_code = "eval('__import__(\"os\").system(\"rm -rf /\")')"

scan = engine.scan_code(unsafe_code)
print(f"Is Safe: {scan.is_safe}")            # False
print(f"Violations: {scan.violations}")      # ['Forbidden call: eval()']

3. MTPO Concurrency Ring

from xoras import HexCellRing

ring = HexCellRing()
ring.write_slot(index=0, payload="DAXX_STATE_INITIALIZED")
ring.write_slot(index=1, payload="VANCE_AUDIT_PASS")

print("Slot 0:", ring.read_slot(0))
print("Slot 1:", ring.read_slot(1))

CLI Usage

The package provides the xoras command-line interface:

# Initialize workspace governance (.xorasrules, xoras.env.yaml)
xoras init

# Run AST security and secret scan on a script or directory
xoras scan my_script.py

# Execute a script inside the sandboxed runtime
xoras run my_script.py

# Run the built-in self-verification test suite
xoras test

Testing & Verification

The framework bundles an internal 31-test self-verification suite that tests AST security gating, DAXX council orchestration, MTPO concurrency, and Merkle DAG provenance right out of the box.

Run verification directly from the command line:

xoras test

Or verify directly from Python:

import xoras
xoras.test()

All 31 built-in tests run in < 0.25s with 100% pass rate.

License

MIT License — Copyright (c) 2026 XORAS Systems LLC. All rights reserved.