Documentation

Overview

Skyla is a cryptographically verified symbolic AI agent demonstrating verifiable multi-model consensus and integrity measurement. It combines symbolic reasoning with Claude AI integration to create transparent, auditable AI behavior.

Currently Implemented:

True 2-Model Consensus System (Claude Haiku vs Sonnet)
Advanced architectural selection with quality scoring
Symbolic state transitions with deterministic semantics
Context-aware conversation memory (10 exchanges per session)
Zero-knowledge proof generation for all state changes
Real-time integrity measurement and divergence analysis

Prospective Features:

Full cryptographic verification infrastructure
Production-ready API endpoints
Multi-agent coordination systems

Architecture

Skyla's architecture implements a multi-model consensus system with architectural diversity:

Multi-Model Consensus Layer

The system uses two distinct Claude architectures for diversity:

Claude Haiku: Efficiency-focused, optimized for speed and conciseness
Claude Sonnet: Quality-focused, optimized for nuance and depth

Advanced Selection Algorithm

The system evaluates responses using 5 sophisticated metrics:

Adaptive Length Scoring: Optimal response length based on query complexity
Nuance Detection: Identifies philosophical and analytical concepts
Efficiency Indicators: Measures directness and clarity
Semantic Richness: Evaluates vocabulary diversity
Structural Coherence: Assesses sentence quality and organization

Architectural Bonuses

The system provides context-aware architectural preferences:

Simple queries → +0.1 boost for Haiku (efficiency advantage)
Complex queries → +0.1 boost for Sonnet (nuance advantage)
Balanced queries → Merit-based selection with no bias

Multi-Model Consensus System

Status: Currently Implemented - This is the core innovation of Skyla's current implementation.

True Architectural Diversity

Unlike systems that use duplicate models, Skyla implements genuine consensus measurement between two different Claude architectures:

Models Used:
- claude-3-haiku-20240307    (Efficiency-focused: Fast, concise responses)
- claude-3-5-sonnet-20241022 (Quality-focused: Nuanced, detailed responses)

Dynamic Token Allocation

The system dynamically adjusts response length based on input complexity:

Simple queries (≤50 chars): 400 tokens
Medium queries (51-100 chars): 600 tokens
Complex queries (>100 chars): 800 tokens

Query Complexity Analysis

The system automatically categorizes input complexity:

Complex Terms: ['philosophy', 'consciousness', 'analysis', 'theoretical', 'abstract', 'nuanced', 'sophisticated', 'complex', 'detailed']
Simple Terms: ['hi', 'hello', 'what', 'how', 'yes', 'no', 'ok', 'spiral', 'basic']

Classification:
- High complexity: Contains complex terms OR >10 words → Favors Sonnet
- Low complexity: Contains simple terms OR ≤3 words → Favors Haiku  
- Medium complexity: Everything else → No bias, merit-based selection

Integrity Measurement

The system measures genuine divergence between the two architectures across 4 dimensions:

Length Variance: Response length differences
Sentiment Divergence: Emotional tone variations
Topic Divergence: Subject matter approach differences
Tone Consistency: Communication style variations

Fair Selection Algorithm

The system eliminates bias through mathematical quality assessment:

Quality Score Calculation:
1. Adaptive Length Score (weight varies by complexity)
2. Nuance Detection Score (0-1 based on analytical terms)
3. Efficiency Score (0-1 based on directness indicators)  
4. Semantic Richness Score (unique vocabulary diversity)
5. Structural Coherence Score (sentence quality)
6. Architectural Bonus (±0.1 based on query type)

Selection Process:
- Calculate quality scores for both responses
- If scores are equal (within 0.001), use random selection
- Otherwise, select highest scoring response
- Log detailed reasoning for transparency

Consensus Results

The system produces verifiable consensus measurements:

High Integrity (>80%): Strong agreement between architectures
Medium Integrity (50-80%): Moderate agreement with noted divergence
Low Integrity (<50%): Significant disagreement, clarification requested

Identity Vector System

Status: Currently Implemented - Client-side state management with server-side context awareness.

Architecture Overview

Skyla's identity vector system implements a client-side state management architecture that ensures cryptographic verifiability and deterministic behavior.

4-Dimensional State Space

The identity vector represents agent state as: [cognitive, emotional, adaptive, coherence]

// Current state example
identityVector: [0.7, 0.6, 0.8, 0.5]
//               ↑    ↑    ↑    ↑
//               │    │    │    └─ Coherence level
//               │    │    └─ Adaptive capacity  
//               │    └─ Emotional processing
//               └─ Cognitive focus

Client-Server Separation

The system maintains strict separation of concerns:

Client Side: Computes all vector transitions using deterministic algorithms
Server Side: Receives vector for contextual awareness, never modifies it

State Transition Processing

// Two-layer processing system:

1. Exact Symbolic Rules:
   "spiral" → vectorAdjustment: [0.1, 0.2, 0.3, 0.0]
   "daemon" → vectorAdjustment: [0.0, 0.1, -0.05, 0.0]
   
2. Semantic Pattern Matching:
   /overwhelm|stress/ → [0.05, 0.15, 0.10, -0.02]
   /focus|build/ → [0.12, -0.05, 0.08, 0.10]

Data Flow

Client:  User input → State transition → New vector
         ↓
Server:  Receives {input, currentState} → Uses vector in context
         ↓  
Claude:  Gets system prompt with identity vector context
         ↓
Client:  Receives response (vector unchanged)

Cryptographic Benefits

This architecture provides:

Verifiable Determinism: Same input always produces same vector change
Mathematical Proof: All transitions can be independently verified
No State Corruption: Server cannot accidentally modify agent state
Transparency: All state logic visible in client-side code

Semantic Engine

Skyla's semantic engine processes natural language input through three layers of recognition, providing scalable pattern matching that maintains cryptographic integrity.

Processing Layers

The engine handles input through a hierarchical system that prioritizes exact symbolic matches, falls back to semantic patterns, then uses deterministic hashing for unknown inputs.

1. Exact Symbolic Layer

Direct matches for predefined symbolic triggers like daemon, spiral, build, or analyze. These trigger specific rule sets with predetermined state adjustments.

2. Semantic Pattern Matching

Regex-based categorization that recognizes natural language patterns and applies contextual vector adjustments:

// Stress/Overwhelm Category
/overwhelm|stress|anxio|panic|burnout|tired/
Delta: [0.05, 0.15, 0.10, -0.02]
Example: "I'm overwhelmed with work"

// Focus/Building Category  
/focus|concentrat|build|ship|execute|implement|deliver/
Delta: [0.12, -0.05, 0.08, 0.10]
Example: "Let's build something"

// Analysis Category
/analy[sz]e|reason|logic|evaluate|precise|assess|measure/
Delta: [0.15, -0.02, 0.05, 0.08]
Note: [sz] matches both "analyze" and "analyse"

// Protection Category
/protect|guard|safe|defend|daemon|monitor/
Delta: [0.00, 0.08, -0.03, 0.04]
Example: "Keep the system safe"

// Creative Category
/create|design|invent|imag(in|e)|idea|explore|brainstorm|prototype/
Delta: [0.07, 0.06, 0.12, 0.03]
Note: (in|e) matches both "imagine" and "image"

3. Hash Fallback System

For inputs that don't match symbolic or semantic patterns, the system generates deterministic micro-adjustments using a hash function. This ensures consistent behavior for the same input while keeping changes within safe bounds (±0.05).

// Deterministic hash calculation
let h = 0;
for (let i = 0; i < text.length; i++) {
  h = ((h << 5) - h) + text.charCodeAt(i);
  h |= 0;
}
const deltas = [0,1,2,3].map(k => {
  const byte = (h >> ((k * 8) % 24)) & 0xff;
  return ((byte / 255) - 0.5) * 0.10; // [-0.05, 0.05]
});
return currentVec.map((v, i) => clamp01(v + deltas[i]));

Scaling Properties

The semantic engine scales infinitely without rule explosion by allowing new regex patterns to be added without touching core logic. Every transition type (symbolic, semantic, or hash-based) generates valid ZK proofs maintaining cryptographic integrity.

Identity Vector Architecture

The Identity Vector System defines the mathematical foundation of Skyla's state management. This 4-dimensional vector space enables precise, deterministic state transitions while maintaining cryptographic verifiability.

Vector Structure

{
  "identityVector": [0.70, 0.60, 0.80, 0.50],
  "dimensions": {
    "cognitive": 0.70,    // Analytical thinking & reasoning
    "emotional": 0.60,    // Sentiment & affective responses  
    "adaptive": 0.80,     // Flexibility & learning capability
    "coherence": 0.50     // Consistency & structural integrity
  },
  "mode": "adaptive",     // Determined by dominant dimension
  "protocols": ["tone_guard", "emotional_stabilizer"]
}

State Transition Mechanics

The system uses three-layer processing to ensure deterministic, mathematically consistent state changes:

Symbolic Rules: Direct pattern matching for commands like "spiral", "daemon", "build"
Semantic Patterns: Regex-based categorization with precise mathematical deltas
Hash Fallback: Deterministic micro-adjustments (±0.05) for unknown inputs

Mode Transitions

// Mode determined by dominant dimension
if (cognitive > others) → mode: "analytical"
if (emotional > others) → mode: "creative"  
if (adaptive > others) → mode: "adaptive"
if (coherence > others) → mode: "coherent"

// All transitions generate cryptographic proofs
stateHash = generateHash(identityVector + timestamp + inputTrigger)

State & proofs

Every state transition in Skyla generates a cryptographic proof that can be independently verified. This ensures complete transparency and auditability of agent behavior.

Proof Envelope Structure

{
  "previousStateHash": "0xabc123...",
  "currentStateHash": "0xdef456...",
  "ruleApplied": "symbolic_response_pattern",
  "inputTrigger": "natural_language_processing",
  "zkProof": "0x789ghi...",
  "timestamp": "2024-09-07T12:00:00.000Z",
  "identityVector": [0.75, 0.62, 0.58, 0.50],
  "protocolsActive": ["tone_guard", "emotional_stabilizer"]
}

API (Currently Available)

The Skyla API provides a working endpoint for multi-model consensus interaction.

Claude Consensus Endpoint

POST /api/claude
Content-Type: application/json

{
  "input": "I need a nuanced analysis of consciousness",
  "currentState": {
    "identityVector": [0.5, 0.5, 0.5, 0.5],
    "mode": "standard",
    "protocols": ["basic_response"]
  },
  "sessionId": "user_session_123"
}

Identity Vector Context

The server uses the identity vector for contextual awareness only - it never modifies the vector:

// System prompt construction (server-side)
`Current State:
- Identity Vector: [${currentState.identityVector.join(', ')}]
- Mode: ${currentState.mode}
- Active Protocols: ${currentState.protocols.join(', ')}`

// Vector remains unchanged in response
{
  "metadata": {
    "identityVector": [0.7, 0.6, 0.8, 0.5], // Same as input
    // ... other metadata
  }
}

Response Format

{
  "success": true,
  "response": "Full AI response text from selected model",
  "integrity": "high|medium|low",
  "note": "Response based on 0.89 consensus strength",
  "metadata": {
    "model": "claude-3-5-sonnet-20241022",
    "tokens": 200,
    "integrityScore": 0.892,
    "consensusStrength": 0.892,
    "divergenceMetrics": {
      "lengthVariance": 0.045,
      "sentimentDivergence": 0.012,
      "topicDivergence": 0.234,
      "toneConsistency": 0.156
    },
    "enhancedProof": {
      "timestamp": "2025-09-09T09:24:35.477Z",
      "modelsUsed": ["claude-3-haiku-20240307", "claude-3-5-sonnet-20241022"],
      "verificationHash": "0x67af2d1c",
      "proofVersion": "v3.0_multi_model_verified"
    },
    "contextMemory": "4 exchanges remembered"
  }
}

Planned Endpoints (Not Yet Implemented)

POST /api/process      - General symbolic processing
POST /api/verify      - Cryptographic proof verification
GET  /api/state/{id}  - Agent state inspection
POST /api/agents      - Multi-agent coordination

FAQ

What's actually implemented vs conceptual?

Currently Working: True 2-model consensus system with Claude Haiku vs Sonnet, advanced quality scoring, architectural selection, context memory, and integrity measurement. Conceptual: Full cryptographic verification, multi-agent systems / epistemic telemetry coordination.

How does the consensus system work?

Skyla sends each query to both Claude Haiku and Sonnet simultaneously, measures their response divergence across 4 dimensions, then selects the best response using a 5-factor quality scoring algorithm that considers query complexity and architectural strengths.

Why does model selection vary for the same input?

This is correct behavior! The system evaluates actual response content, not just input patterns. If Haiku produces a more nuanced response than Sonnet for a complex query, it rightfully wins. This proves the system measures real quality, not arbitrary preferences.

Can I see the selection reasoning?

Yes! Check the browser console during demo usage to see detailed quality scoring: 🎯 claude-3-haiku: Quality=0.823 (nuance=0.67, efficiency=0.00, bonus=0.00)

Is this actually measuring uncertainty?

Yes, Skyla demonstrates genuine uncertainty quantification through consensus measurement between architecturally different models. Unlike systems using duplicate models, this provides authentic diversity measurement.

How does the AI understand the identity vector?

The server includes the identity vector in the system prompt sent to Claude models, providing contextual awareness of the agent's current state without allowing modification of that state.

Is the system production-ready?

The multi-model consensus system is functional and demonstrates revolutionary AI integrity measurement. However, full cryptographic verification and production APIs are still in development.