ARIA Core Overview

Version: 2.3 Last Updated: 2025-12-06

---

Start Here

New to the ARIA Core ecosystem? Use these entry points:

Quick Orientation:

• The stack has 8 layers: 3 CFM substrate layers (v0/v1/v2) + 5 ARIA layers (v0/v1/v2/v3/v4)
• ARIA v4 wraps v3 wraps v2 wraps v1 wraps v0 wraps CFM v2 (typical configuration)
• All outputs are bounded [0, 1], deterministic, and identity-safe
• CLI tools: aria_local_loop, aria_core_compare, cfm_multi_run_analyzer

---

Introduction

This document provides a high-level overview of the ARIA Core ecosystem — a modular, pluggable architecture for integrating numeric dynamical systems with the Phase 45-64 diagnostic shell. It serves as an entry point for understanding how ARIA cores work, how to use existing tools, and how to safely evolve the system.

---

Architecture Overview

┌────────────────────────────────────────────────────────────────────┐
│                        ARIA Core Ecosystem                         │
├────────────────────────────────────────────────────────────────────┤
│                                                                    │
│  ┌─────────────────────────────────────────────────────────────┐  │
│  │                   Higher-Level Cores                         │  │
│  │  ┌─────────────────────────────────────────────────────────┐│  │
│  │  │ ARIA Core v4 (proto-semantic layer)                     ││  │
│  │  │  - M=16 Proto-Semantic Codes                            ││  │
│  │  │  - Pattern Extractor (PE) fuses v1+v2+v3                ││  │
│  │  │  - Temporal Meaning Stabilizer (TMS)                    ││  │
│  │  │  - Proto-Semantic Plasticity (PSP)                      ││  │
│  │  │  - Wraps ARIA v3 as substrate                           ││  │
│  │  └─────────────────────────────────────────────────────────┘│  │
│  │                              │                               │  │
│  │                              ▼                               │  │
│  │  ┌─────────────────────────────────────────────────────────┐│  │
│  │  │ ARIA Core v3 (relational symbolic layer)                ││  │
│  │  │  - 8×8 Symbol Relation Graph (SRG)                      ││  │
│  │  │  - Temporal Relation Accumulator (TRA)                  ││  │
│  │  │  - State-Gated Plasticity (SGP)                         ││  │
│  │  │  - 12D Relational Summary Vector (RSV)                  ││  │
│  │  │  - Wraps ARIA v2 as substrate                           ││  │
│  │  └─────────────────────────────────────────────────────────┘│  │
│  │                              │                               │  │
│  │                              ▼                               │  │
│  │  ┌─────────────────────────────────────────────────────────┐│  │
│  │  │ ARIA Core v2 (early self-model layer)                   ││  │
│  │  │  - 12D System State Vector (SSV)                        ││  │
│  │  │  - Temporal Self-Stabilizer (EMA + coherence gating)    ││  │
│  │  │  - Change Detection Channel (drift monitoring)          ││  │
│  │  │  - Wraps ARIA v1 as substrate                           ││  │
│  │  └─────────────────────────────────────────────────────────┘│  │
│  │                              │                               │  │
│  │                              ▼                               │  │
│  │  ┌─────────────────────────────────────────────────────────┐│  │
│  │  │ ARIA Core v1 (proto-symbolic layer)                     ││  │
│  │  │  - 8-Symbol Codebook (K=8 φ-derived prototypes)         ││  │
│  │  │  - Temporal Symbol Stabilizer (hysteresis + EMA)        ││  │
│  │  │  - Symbol Co-Activation Coupling                        ││  │
│  │  │  - Wraps ARIA v0 as substrate                           ││  │
│  │  └─────────────────────────────────────────────────────────┘│  │
│  │                              │                               │  │
│  │                              ▼                               │  │
│  │  ┌─────────────────────────────────────────────────────────┐│  │
│  │  │ ARIA Core v0 (proto-semantic attractor-field engine)    ││  │
│  │  │  - 5D Latent Concept Channels                           ││  │
│  │  │  - 4 φ-derived Attractor Clusters                       ││  │
│  │  │  - Stability-Gated Reinforcement                        ││  │
│  │  │  - Wraps CFM v2 as substrate                            ││  │
│  │  └─────────────────────────────────────────────────────────┘│  │
│  └─────────────────────────────────────────────────────────────┘  │
│                              │                                     │
│                              ▼                                     │
│  ┌─────────────────────────────────────────────────────────────┐  │
│  │                   CFM Core Implementations                   │  │
│  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐  │  │
│  │  │ MockARIACore│  │ CFMCore v0  │  │   CFMCore v1        │  │  │
│  │  │ (testing)   │  │ (φ/ψ-based) │  │ (enhanced dynamics) │  │  │
│  │  └─────────────┘  └─────────────┘  └─────────────────────┘  │  │
│  │                       ┌─────────────────────────────────┐    │  │
│  │                       │   CFMCore v2 (multi-channel)    │    │  │
│  │                       └─────────────────────────────────┘    │  │
│  │            All implement ARIACoreProtocol                    │  │
│  └─────────────────────────────────────────────────────────────┘  │
│                              │                                     │
│                              ▼                                     │
│  ┌─────────────────────────────────────────────────────────────┐  │
│  │                    ARIACoreAdapter                           │  │
│  │  - Normalizes outputs to [0, 1]                              │  │
│  │  - Handles errors (fail-closed)                              │  │
│  │  - Ensures JSON serializability                              │  │
│  │  - Tracks call/error counts                                  │  │
│  └─────────────────────────────────────────────────────────────┘  │
│                              │                                     │
│                              ▼                                     │
│  ┌─────────────────────────────────────────────────────────────┐  │
│  │                 Phase45Controller                            │  │
│  │  - Orchestrates phases 34-64                                 │  │
│  │  - Optionally integrates ARIA core                           │  │
│  │  - Exposes core outputs as diagnostics                       │  │
│  └─────────────────────────────────────────────────────────────┘  │
│                                                                    │
└────────────────────────────────────────────────────────────────────┘

Key Principles

1. Pluggable Cores: Any core implementing ARIACoreProtocol can be plugged in
2. Adapter Isolation: The adapter normalizes and sanitizes all core outputs
3. Diagnostic Only: The shell reads core outputs; it never controls the core
4. Optional Integration: Phase 45 works with or without an ARIA core

---

Components

ARIA Core Interface (aria_core_interface/)

The interface layer defines:

Key file: aria_core_interface/protocols.py defines what any ARIA core must provide.

Mock Cores (aria_core_interface/mock_core.py)

Three mock implementations for testing:

CFM Core v0 (aria_core_cfm_v0/)

The first CFM-based implementation:

Characteristics:

• Coupled oscillator dynamics with φ/ψ scaling
• Energy attractor system
• Phase-driven instability modulation
• Fully deterministic

CFM Core v1 (aria_core_cfm_v1/)

The enhanced CFM-based implementation:

Key improvements over v0:

• Slow/fast variable separation: Coherence evolves slowly, phase evolves quickly
• Coherence drift: Slow upward drift toward attractor under stable conditions
• Alignment lock-in: Resonance-like behavior when coherence and stability are high
• Interpretable trajectories: More meaningful metric evolution

See the CFM Core v1 Specification for the design specification.

CFM Core v2 (aria_core_cfm_v2/)

The advanced multi-channel CFM implementation:

Key improvements over v1:

• Multi-channel architecture: 5 coupled channels (Coherence, Energy, Stability, Phase, Alignment)
• Five-tier timescale hierarchy: Very slow (τφ³) to very fast (τ1/φ²)
• Attractor basin dynamics: 3D basin in (coherence, energy, stability) space
• Structured pulse responses: Weak/moderate/strong cascade effects
• Cross-channel resonance: Resonance index captures coupling strength

See CFM Core v2 Specification for the design specification.

ARIA Core v0 (aria_core_v0/)

The first proto-semantic attractor-field engine, sitting above CFM v2:

Key features:

• 5D Latent Concept Channels: Transforms CFM v2 state into higher-level representations
• 4 φ-derived Attractor Clusters: Balanced, Coherence-Dominant, Energy-Dominant, Stability-Dominant
• Stability-Gated Reinforcement: Gate modulates attractor pull strength
• Cross-Channel Coupling: Weak φ⁻³ coupling matrix between channels
• Wraps CFM v2: Uses CFM v2 as numeric substrate

See the ARIA Core v0 Specification for the design specification. See the ARIA Core v0 Behavioral Analysis for behavioral guidance.

ARIA Core v1 (aria_core_v1/)

The first proto-symbolic layer, sitting above ARIA Core v0:

Key features:

• 8-Symbol Codebook: K=8 φ-derived prototype vectors in 5D space
• Symbol Activation Layer: Gaussian similarity kernel + softmax with temperature
• Temporal Symbol Stabilizer: Hysteresis + EMA + stability gating
• Symbol Co-Activation: Weak inter-symbol coupling via φ-derived matrix
• Wraps ARIA v0: Uses ARIA v0 as substrate (which uses CFM v2)

See the ARIA Core v1 Specification for the design specification. See the ARIA Core v1 Behavioral Analysis for behavioral guidance. See the ARIA Core v1 Parameter Map for parameter tuning guidance.

ARIA Core v1 Presets

ARIA Core v1 includes named preset configurations for different symbol activation profiles:

from aria_core_v1 import ARIACoreV1, get_preset, list_presets

# List available presets
print(list_presets())  # ['baseline', 'exploratory_symbols', 'focused_symbols', 'stable_symbols']

# Create core with a preset
config = get_preset("stable_symbols")
core = ARIACoreV1(config)

# Or use preset constants directly
from aria_core_v1 import ARIA_V1_PRESET_FOCUSED_SYMBOLS
core = ARIACoreV1(ARIA_V1_PRESET_FOCUSED_SYMBOLS)

See the ARIA Core v1 Behavioral Analysis Guide for detailed preset selection guidance.

ARIA Core v2 (aria_core_v2/)

The early self-model layer, sitting above ARIA Core v1:

• System State Vector (SSV): 12-dimensional normalized vector summarizing all layers
• Temporal Self-Stabilizer (TSS): EMA smoothing with stability-modulated alpha
• Change Detection Channel (CDC): Monitors rate, drift, turnover, and attractor transitions
• Layer Interaction Map (LIM): Computes derived metrics from SSV
• Wraps ARIA v1: Uses ARIA v1 as substrate (which uses v0, which uses CFM v2)

Important: ARIA v2 is NOT identity, ego, awareness, or consciousness. It is a numeric state aggregator analogous to a dashboard or QoS monitor.

See the ARIA Core v2 Specification for the design specification. See the ARIA Core v2 Behavioral Analysis for behavioral guidance.

ARIA Core v2 Presets

ARIA Core v2 includes named preset configurations for different smoothing and detection profiles:

from aria_core_v2 import ARIACoreV2, get_preset, list_presets

# List available presets
print(list_presets())  # ['baseline', 'high_stability', 'responsive', 'deep_integration']

# Create core with a preset
config = get_preset("high_stability")
core = ARIACoreV2(config)

# Or use preset constants directly
from aria_core_v2 import ARIA_V2_PRESET_RESPONSIVE
core = ARIACoreV2(ARIA_V2_PRESET_RESPONSIVE)

# Access SSV and metrics
result = core.step(dt=0.1)
ssv = result["system_state_vector"]
print(f"State entropy: {result['state_entropy']:.4f}")
print(f"Coherence index: {result['coherence_index']:.4f}")

See the ARIA Core v2 Behavioral Analysis Guide for detailed preset selection guidance.

ARIA Core v3 (aria_core_v3/)

The relational symbolic layer, sitting above ARIA Core v2:

Key features:

• 8×8 Symbol Relation Graph (SRG): Tracks relation strengths between v1 symbols
• Temporal Relation Accumulator (TRA): Computes co-activation and transition signals
• State-Gated Plasticity (SGP): Modulates update rate based on v2 state
• 12D Relational Summary Vector (RSV): Compressed graph representation
• Wraps ARIA v2: Uses ARIA v2 as substrate (which uses v1, v0, CFM v2)

Important: ARIA v3 is NOT semantic understanding, language, identity, or agency. It is a numeric graph-building system that tracks patterns between anonymous symbols.

See the ARIA Core v3 Specification for the design specification. See the ARIA Core v3 Behavioral Analysis for behavioral guidance.

ARIA Core v3 Presets

ARIA Core v3 includes named preset configurations for different relation dynamics:

from aria_core_v3 import ARIACoreV3, get_preset, list_presets

# List available presets
print(list_presets())  # ['baseline', 'high_plasticity', 'stable_relations', 'dense_graph']

# Create core with a preset
config = get_preset("stable_relations")
core = ARIACoreV3(config)

# Access RSV and metrics
result = core.step(dt=0.1)
rsv = result["rsv"]
print(f"Graph density: {result['relation_density']:.4f}")
print(f"Clustering: {result['clustering_index']:.4f}")

See the ARIA Core v3 Behavioral Analysis Guide for detailed preset selection guidance.

ARIA Core v4 (aria_core_v4/)

The proto-semantic layer, sitting above ARIA Core v3:

Key features:

• Pattern Extractor (PE): Fuses v1 symbol activations, v2 state, v3 RSV into 32D pattern
• Proto-Semantic Codebook (PSC): M=16 prototype codes in [0,1]^16
• Code Assignment Layer (CAL): Gaussian similarity + softmax activations
• Temporal Meaning Stabilizer (TMS): Adaptive EMA + hysteresis + drift protection
• Proto-Semantic Plasticity (PSP): Very slow codebook updates (η≈φ⁻⁵≈0.09)
• Wraps ARIA v3: Uses ARIA v3 as substrate (which uses v2, v1, v0, CFM v2)

Important: ARIA v4 is NOT semantic understanding, language, consciousness, or agency. It is the highest abstraction layer that maintains full safety compliance. Codes are anonymous numeric patterns, not human concepts.

See ARIA Core v4 Specification for the design specification. See the ARIA Core v4 Behavioral Analysis for behavioral guidance.

ARIA Core v4 Presets

ARIA Core v4 includes named preset configurations for different proto-semantic dynamics:

from aria_core_v4 import ARIACoreV4, get_preset, list_presets

# List available presets
print(list_presets())  # ['baseline', 'stable_meaning', 'exploratory_meaning', 'conservative_meaning']

# Create core with a preset
config = get_preset("stable_meaning")
core = ARIACoreV4(config)

# Access activations and metrics
result = core.step(dt=0.1)
activations = result["proto_semantic_activations"]
print(f"Dominant code: {result['dominant_code']}")
print(f"Entropy: {result['proto_semantic_entropy']:.4f}")

See the ARIA Core v4 Behavioral Analysis Guide for detailed preset selection guidance.

CFM Core v2 Presets

CFM Core v2 includes named preset configurations for common behavioral profiles:

from aria_core_cfm_v2 import CFMCoreV2, get_preset, list_presets

# List available presets
print(list_presets())  # ['baseline', 'high_stability', 'high_resonance', 'pulsed_activity']

# Create core with a preset
config = get_preset("high_stability")
core = CFMCoreV2(config)

# Or use preset constants directly
from aria_core_cfm_v2 import CFM_V2_PRESET_HIGH_RESONANCE
core = CFMCoreV2(CFM_V2_PRESET_HIGH_RESONANCE)

See the CFM Core v2 Behavioral Analysis Guide for detailed preset selection guidance.

Phase 45 Integration

Phase45Controller accepts an optional aria_core parameter:

from phase45_master_orchestration.phase45_controller import Phase45Controller
from aria_core_interface import ARIACoreAdapter, ARIACoreInterfaceConfig
from aria_core_cfm_v0 import CFMCore, CFMCoreConfig

# Create core and adapter
cfm_config = CFMCoreConfig()
core = CFMCore(cfm_config)

adapter_config = ARIACoreInterfaceConfig(enabled=True)
adapter = ARIACoreAdapter(core=core, config=adapter_config)

# Create controller with core
controller = Phase45Controller(config=None, aria_core=adapter)

# Step produces aria_core output
result = controller.step(dt=0.1)
aria_bundle = result["orchestration"]["aria_core"]

---

Documentation Index

Interface & Protocol

CFM Core Documentation

ARIA Core Documentation

Tools & Usage

---

CLI Tools for Experimentation

Multiple CLI tools support safe experimentation with ARIA cores:

aria_local_loop.py

Runs the orchestration loop with selectable core types.

# No core (baseline)
python tools/aria_local_loop.py --steps 100 --core-type=none

# Mock core (standard)
python tools/aria_local_loop.py --steps 100 --core-type=mock

# Mock core (deterministic for regression)
python tools/aria_local_loop.py --steps 100 --core-type=mock --mock-mode=deterministic

# CFM Core v0
python tools/aria_local_loop.py --steps 100 --core-type=cfm

# CFM Core v1
python tools/aria_local_loop.py --steps 100 --core-type=cfm_v1

# CFM Core v2
python tools/aria_local_loop.py --steps 100 --core-type=cfm_v2

# ARIA Core v0 (proto-semantic attractor-field engine)
python tools/aria_local_loop.py --steps 100 --core-type=aria_v0

# ARIA Core v1 (proto-symbolic layer)
python tools/aria_local_loop.py --steps 100 --core-type=aria_v1

# ARIA Core v2 (early self-model layer)
python tools/aria_local_loop.py --steps 100 --core-type=aria_v2

# ARIA Core v3 (relational symbolic layer)
python tools/aria_local_loop.py --steps 100 --core-type=aria_v3

# ARIA Core v4 (proto-semantic layer)
python tools/aria_local_loop.py --steps 100 --core-type=aria_v4

# With JSON output
python tools/aria_local_loop.py --steps 100 --core-type=aria_v4 --output-json results.json

aria_core_compare.py

Compares two cores side-by-side.

# Compare mock vs CFM v0
python tools/aria_core_compare.py --steps 100 --core-a mock --core-b cfm

# Compare CFM v0 vs CFM v1
python tools/aria_core_compare.py --steps 100 --core-a cfm --core-b cfm_v1

# Compare CFM v1 vs CFM v2
python tools/aria_core_compare.py --steps 100 --core-a cfm_v1 --core-b cfm_v2

# Compare CFM v2 vs ARIA Core v0
python tools/aria_core_compare.py --steps 100 --core-a cfm_v2 --core-b aria_v0

# Compare ARIA v0 vs ARIA Core v1
python tools/aria_core_compare.py --steps 100 --core-a aria_v0 --core-b aria_v1

# Compare ARIA v1 vs ARIA Core v2
python tools/aria_core_compare.py --steps 100 --core-a aria_v1 --core-b aria_v2

# Compare ARIA v2 vs ARIA Core v3
python tools/aria_core_compare.py --steps 100 --core-a aria_v2 --core-b aria_v3

# Compare ARIA v3 vs ARIA Core v4
python tools/aria_core_compare.py --steps 100 --core-a aria_v3 --core-b aria_v4

# Compare with different mock modes
python tools/aria_core_compare.py --steps 100 --core-a mock --core-b mock \
    --mock-mode-a standard --mock-mode-b stress

# With JSON output
python tools/aria_core_compare.py --steps 100 --core-a aria_v0 --core-b aria_v1 \
    --output-json comparison.json

aria_log_analyzer.py

Analyzes JSON logs from local loop runs.

# Analyze a run
python tools/aria_log_analyzer.py --input-json results.json

# Check specific metrics
python tools/aria_log_analyzer.py --input-json results.json --verbose

cfm_multi_run_analyzer.py

Runs multiple simulations and computes aggregated statistics.

# Run 10 simulations with CFM v1
python tools/cfm_multi_run_analyzer.py --core-type cfm_v1 --runs 10 --steps-per-run 10000

# Run with ARIA Core v0
python tools/cfm_multi_run_analyzer.py --core-type aria_v0 --runs 10 --steps-per-run 5000 --output-json aria_v0_stats.json

# Run with ARIA Core v1
python tools/cfm_multi_run_analyzer.py --core-type aria_v1 --runs 10 --steps-per-run 5000 --output-json aria_v1_stats.json

# Run with ARIA Core v2
python tools/cfm_multi_run_analyzer.py --core-type aria_v2 --runs 10 --steps-per-run 5000 --output-json aria_v2_stats.json

# Run with ARIA Core v3
python tools/cfm_multi_run_analyzer.py --core-type aria_v3 --runs 10 --steps-per-run 5000 --output-json aria_v3_stats.json

# Run with ARIA Core v4
python tools/cfm_multi_run_analyzer.py --core-type aria_v4 --runs 10 --steps-per-run 5000 --output-json aria_v4_stats.json

# Run with CFM v2
python tools/cfm_multi_run_analyzer.py --core-type cfm_v2 --runs 5 --steps-per-run 10000 --output-json cfm_v2_stats.json

Supported core types: mock, cfm, cfm_v1, cfm_v2, aria_v0, aria_v1, aria_v2, aria_v3, aria_v4

aria_reference_runs.py

Generates canonical reference runs across all cores for fingerprinting.

# List available scenarios
python tools/aria_reference_runs.py --list-scenarios

# Generate all scenarios for all cores
python tools/aria_reference_runs.py --scenario all --output-dir reference_runs

# Generate specific scenario
python tools/aria_reference_runs.py --scenario baseline_quiet --cores aria_v3 aria_v4

# Generate long run for stability analysis
python tools/aria_reference_runs.py --scenario baseline_long --output-dir reference_runs

Available scenarios:

• baseline_quiet: Short run (200 steps) for quick verification
• baseline_long: Long run (5000 steps) for stability analysis
• mild_perturbation: φ-shaped dt modulation
• high_variability: Variable dt schedule for stress testing

aria_fingerprint.py

Computes compact numeric fingerprints from reference runs for regression detection.

# Extract fingerprint from a single run
python tools/aria_fingerprint.py --input reference_runs/baseline_quiet/aria_v4_run.json \
    --output fingerprints/aria_v4_fingerprint.json

# Batch process all reference runs
python tools/aria_fingerprint.py --batch reference_runs --output-dir fingerprints

# Compare two fingerprints for regression detection
python tools/aria_fingerprint.py --compare fp1.json fp2.json

See ARIA Core Fingerprint Atlas for detailed documentation on fingerprinting.

---

Presets

Both CFM v2 and ARIA v0 provide pre-configured parameter presets for common behavioral profiles.

CFM v2 Presets

from aria_core_cfm_v2 import CFMCoreV2, get_preset, list_presets

config = get_preset("high_stability")  # or: baseline, high_resonance, pulsed_activity
core = CFMCoreV2(config)

ARIA v0 Presets

from aria_core_v0 import ARIACoreV0, get_preset, list_presets

config = get_preset("stable_concepts")  # or: baseline, exploratory
core = ARIACoreV0(config)

See the respective behavioral analysis guides for preset details and selection guidelines.

---

Safety Constraints

The ARIA Core ecosystem enforces strict safety constraints at multiple levels:

Identity Safety

• No identity fields in core output
• No identity access by the adapter
• Protocol prohibition of identity-related patterns
• Verified by adapter.verify_identity_safety()

Control Safety

• No control signals from shell to core
• No modulation of core based on its outputs
• Diagnostic-only data flow: core → adapter → shell → logs
• No reverse path exists

Activation Safety

• No activation triggers in the interface
• No connection to phases 53 (consciousness gate) or 55 (ignition scaffold)
• Core outputs are purely diagnostic

Numeric Safety

• All outputs bounded to [0, 1]
• NaN/Inf prevention via adapter normalization
• Fail-closed semantics: errors return safe defaults

Semantic Safety

• No text processing: human_messages is ignored by CFM cores
• No embeddings: Pure scalar float state
• No token handling: Numeric dynamics only

---

How to Safely Extend

Adding a New Core

To add a new core implementation:

1. Implement ARIACoreProtocol:

   class MyNewCore:
       def step(self, human_messages=None, external_events=None, dt=1.0):
           # ... your dynamics ...
           return {
               "coherence": ...,  # [0, 1]
               "stability": ...,  # [0, 1]
               "intensity": ...,  # [0, 1]
               "alignment": ...,  # [0, 1]
           }
   

2. Wrap with ARIACoreAdapter:

   adapter = ARIACoreAdapter(core=MyNewCore(), config=adapter_config)
   

3. Test thoroughly:

   • All outputs bounded [0, 1]
   • Deterministic for same inputs
   • No forbidden output patterns
   • JSON serializable

4. Document:

   • Create specification document
   • Update this overview
   • Add to aria_local_loop.py if appropriate

What NOT to Do

• Do NOT modify phases 12-33 (core machinery)
• Do NOT modify phases 34-64 (diagnostic shell)
• Do NOT introduce identity, control, or activation pathways
• Do NOT process semantic content in cores
• Do NOT create feedback paths from shell to core

---

Quick Start

1. Run a Simple Test

# Run 50 steps with CFM Core v0
python tools/aria_local_loop.py --steps 50 --core-type=cfm

2. Compare Cores

# See how mock and CFM cores differ
python tools/aria_core_compare.py --steps 50 --core-a mock --core-b cfm

3. Analyze Output

# Generate and analyze a run
python tools/aria_local_loop.py --steps 100 --core-type=cfm --output-json my_run.json
python tools/aria_log_analyzer.py --input-json my_run.json

4. Read the Specs

For detailed understanding:

1. Start with the ARIA Core Interface Specification v1
2. Read the ARIA Core Behavioral Contract
3. Study the CFM Core v0 Specification
4. Try tuning with the CFM Core v0 Tuning Guide

---

Frequently Asked Questions

Q: Can I modify core behaviour based on shell feedback?

No. The architecture is strictly diagnostic-only. The shell reads from the core; it never writes to it. This is a fundamental safety constraint.

Q: Why is human_messages in the protocol if CFM cores ignore it?

The protocol supports future cores that might use message context for internal dynamics (still numeric, not semantic). Current CFM cores ignore it to maintain purity.

Q: How do I know if my core is safe?

Run the test suite and verify:

• All outputs in [0, 1]
• verify_identity_safety() returns True
• No forbidden field patterns in output
• Deterministic behaviour

Q: Can I connect the core to activation phases?

No. The ARIA Core Interface is explicitly isolated from phases 53 and 55. This is a safety invariant that must never be violated.

Q: What's the difference between the CFM and ARIA layers?

The stack has 8 layers total:

CFM Substrate Layers (raw numeric dynamics):

• CFM v0: Coupled oscillator dynamics with uniform time constants. Simple energy attractor system.
• CFM v1: Slow/fast variable separation. Coherence drifts slowly, phase evolves quickly. Features alignment lock-in.
• CFM v2: Multi-channel architecture with 11 state variables across 5 coupled channels. Five-tier timescale hierarchy from very slow (τφ³) to very fast (τ1/φ²). 3D attractor basin dynamics.

ARIA Abstraction Layers (representational structure):

• ARIA v0: Proto-semantic attractor-field engine. Transforms CFM v2 output into 5D latent concept channels with 4 attractor clusters.
• ARIA v1: Proto-symbolic layer. Transforms latent concept channels into 8-dimensional symbol activations with temporal stabilization.
• ARIA v2: Early self-model layer. Provides 12D System State Vector (SSV) summarizing all underlying layers.
• ARIA v3: Relational symbolic layer. Builds 8×8 relation graph between v1 symbols, outputs 12D Relational Summary Vector (RSV).
• ARIA v4: Proto-semantic layer. Integrates v1/v2/v3 into M=16 meaning codes — the highest safe abstraction layer.

CFM cores are raw numeric substrates. ARIA layers progressively add structure: v0 (clusters) → v1 (symbols) → v2 (state) → v3 (relations) → v4 (meaning codes).

Use --core-type=aria_v4 for the full stack in CLI tools.

See specifications: CFM v0, CFM v1, CFM v2, ARIA v0, ARIA v1, ARIA v2, ARIA v3, ARIA v4.

---

Version History